@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/functions.js

@@ -0,0 +1,529 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * No-code functions (Component Builder, AGL-92): the mockup's Edit Function
+ * model — parameters, local variables, conditional SET operations, and a
+ * return value — plus a small, safe expression evaluator. No eval(), no
+ * loops, bounded operation count; expressions only reference declared
+ * names, numeric/string/boolean literals, + - * / ( ), and the fixed table
+ * of built-ins below.
+ *
+ * WHAT A REAL CALCULATOR NEEDED (AGL-3202). The first page built on this — a
+ * cost sheet comparing five platforms — could compute its static table and
+ * could not carry its interactive half, for three reasons that live here:
+ *
+ * - No `min`, no rounding, no number formatting. "Cheapest of three plans"
+ *   took three compares, a per-site cost could not be shown at all, and
+ *   "$1,396" was built by peeling thousands off with a ladder of six
+ *   compares. {@link BUILTINS} closes that: a FIXED table, called as
+ *   `name(args)`. Nothing a site author writes can add to it, so the
+ *   evaluator's promise — no eval, no loops, bounded — is unchanged.
+ * - A function could not read a site variable, so a widget's function had
+ *   to repeat every price as a literal. `globals` on
+ *   {@link EvaluateFunctionOptions} is that outer scope: readable, never
+ *   settable, and shadowed by a parameter or local of the same name.
+ * - A parameter was a bare identifier and a type. It may now carry what a
+ *   visitor should see and start with: `label`, `options`, `defaultValue`.
+ */ /**
+ * A choice list as ONE line of text (AGL-3202):
+ * `cms: A CMS and room to grow, entry: The entry plan only`. A bare entry is
+ * both the value and what the visitor reads.
+ *
+ * One line, not a nested editor, because every surface that asks for choices
+ * already asks for several other things in the same row. The cost is that a
+ * value cannot itself contain a comma, and a label cannot either; a choice
+ * that needs one is a sign the question wants rewording.
+ *
+ * In core because two plugins read it — the function builder that stores a
+ * parameter's choices and the canvas element that offers its own — and a
+ * plugin may not import another.
+ */ export function parseFunctionParameterOptions(text) {
+    const options = [];
+    const seen = new Set();
+    for (const part of String(text != null ? text : '').split(',')){
+        const colon = part.indexOf(':');
+        const value = (colon < 0 ? part : part.slice(0, colon)).trim();
+        // The second copy of a value is a typo, not a second choice: a select
+        // with two identical values cannot tell the function which was picked.
+        if (!value || seen.has(value)) continue;
+        seen.add(value);
+        const label = colon < 0 ? '' : part.slice(colon + 1).trim();
+        options.push(label && label !== value ? {
+            value,
+            label
+        } : {
+            value
+        });
+    }
+    return options;
+}
+/** The inverse, for showing a stored list in that one line. */ export function formatFunctionParameterOptions(options) {
+    return (options != null ? options : []).map((option)=>option.label && option.label !== option.value ? `${option.value}: ${option.label}` : option.value).join(', ');
+}
+/**
+ * How many SETs one run may apply. A BOUND, not a budget anyone is meant to
+ * approach: there are no loops, so a run applies at most one SET per SET
+ * written, and this is what stops a definition pasted in by the thousand.
+ *
+ * It was 100, sized for "if P1 <= P2 then P3 = P1 + P2". The first pricing
+ * calculator built on site functions — six plans, a line per meter, a row per
+ * competitor — applies about 150 (AGL-3202). Each SET is one short expression
+ * over a flat scope, so a thousand of them is still well under a millisecond.
+ */ export const FUNCTION_MAX_OPERATIONS = 1000;
+function tokenize(text) {
+    const tokens = [];
+    let index = 0;
+    while(index < text.length){
+        const char = text[index];
+        if (/\s/.test(char)) {
+            index += 1;
+        } else if ('+-*/'.includes(char)) {
+            tokens.push({
+                kind: 'op',
+                value: char
+            });
+            index += 1;
+        } else if (char === '(') {
+            tokens.push({
+                kind: 'lparen'
+            });
+            index += 1;
+        } else if (char === ')') {
+            tokens.push({
+                kind: 'rparen'
+            });
+            index += 1;
+        } else if (char === ',') {
+            // Only meaningful between a built-in's arguments; anywhere else the
+            // parser reports it as trailing input.
+            tokens.push({
+                kind: 'comma'
+            });
+            index += 1;
+        } else if (char === "'" || char === '"') {
+            const end = text.indexOf(char, index + 1);
+            if (end < 0) throw new Error('Unterminated string');
+            tokens.push({
+                kind: 'string',
+                value: text.slice(index + 1, end)
+            });
+            index = end + 1;
+        } else if (/[0-9.]/.test(char)) {
+            const match = /^[0-9]*\.?[0-9]+/.exec(text.slice(index));
+            if (!match) throw new Error(`Bad number at "${text.slice(index)}"`);
+            tokens.push({
+                kind: 'number',
+                value: Number(match[0])
+            });
+            index += match[0].length;
+        } else if (/[a-zA-Z_]/.test(char)) {
+            // A dotted path is ONE name: `plan_pro.annual` reads a member of a
+            // dictionary (AGL-3202). A number never starts here, so `1.5` is not
+            // at risk, and a trailing dot is left for the parser to refuse.
+            const match = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*/.exec(text.slice(index));
+            const word = match[0];
+            if (word === 'true' || word === 'false') {
+                tokens.push({
+                    kind: 'boolean',
+                    value: word === 'true'
+                });
+            } else {
+                tokens.push({
+                    kind: 'ident',
+                    value: word
+                });
+            }
+            index += word.length;
+        } else {
+            throw new Error(`Unexpected character "${char}"`);
+        }
+    }
+    return tokens;
+}
+/** More arguments than any built-in can use; a typo, not a calculation. */ const MAX_CALL_ARGUMENTS = 16;
+/** Decimal places `round` and `format` accept. */ const MAX_DIGITS = 10;
+function digitsOf(value) {
+    if (value === undefined) return 0;
+    const digits = Math.trunc(toNumber(value));
+    if (digits < 0 || digits > MAX_DIGITS) {
+        throw new Error(`Decimal places must be between 0 and ${MAX_DIGITS}`);
+    }
+    return digits;
+}
+/**
+ * Half away from zero, on the DECIMAL value. The exponent form is what makes
+ * `round(1.005, 2)` answer 1.01: multiplying by 100 first gives
+ * 100.49999999999999 and rounds it down.
+ */ function roundTo(value, digits) {
+    const magnitude = Number(`${Math.round(Number(`${Math.abs(value)}e${digits}`))}e-${digits}`);
+    return value < 0 ? -magnitude : magnitude;
+}
+function arity(name, args, least, most) {
+    if (args.length < least || args.length > most) {
+        const wanted = least === most ? `${least}` : `${least} to ${most}`;
+        throw new Error(`${name}() takes ${wanted} argument(s)`);
+    }
+}
+/**
+ * THE WHOLE TABLE, and it is closed. A site author calls these; nothing they
+ * write can add one, and none of them loops, allocates by input size or
+ * reaches outside its arguments.
+ *
+ * `format` is pinned to `en-US` on purpose. The same function runs on the
+ * server for a `{{fn:…}}` token and in a visitor's browser for a widget, and
+ * the machine's own locale would make those two disagree about "1,396".
+ */ const BUILTINS = {
+    min: (args)=>{
+        arity('min', args, 1, MAX_CALL_ARGUMENTS);
+        return Math.min(...args.map(toNumber));
+    },
+    max: (args)=>{
+        arity('max', args, 1, MAX_CALL_ARGUMENTS);
+        return Math.max(...args.map(toNumber));
+    },
+    round: (args)=>{
+        arity('round', args, 1, 2);
+        return roundTo(toNumber(args[0]), digitsOf(args[1]));
+    },
+    floor: (args)=>{
+        arity('floor', args, 1, 1);
+        return Math.floor(toNumber(args[0]));
+    },
+    ceil: (args)=>{
+        arity('ceil', args, 1, 1);
+        return Math.ceil(toNumber(args[0]));
+    },
+    abs: (args)=>{
+        arity('abs', args, 1, 1);
+        return Math.abs(toNumber(args[0]));
+    },
+    format: (args)=>{
+        arity('format', args, 1, 2);
+        const digits = digitsOf(args[1]);
+        return roundTo(toNumber(args[0]), digits).toLocaleString('en-US', {
+            minimumFractionDigits: digits,
+            maximumFractionDigits: digits
+        });
+    }
+};
+// ── Dictionary members (AGL-3202) ──────────────────────────────────────────
+/**
+ * Parsed dictionaries, by their JSON text. A pricing function reads thirty
+ * members of the same six dictionaries on every keystroke, and the text is
+ * the only identity a scope value has. Small and bounded: a page holds a
+ * handful of dictionaries, and a miss only costs a parse.
+ */ const DICTIONARY_CACHE = new Map();
+const DICTIONARY_CACHE_MAX = 64;
+function parseDictionary(text) {
+    var _DICTIONARY_CACHE_get;
+    if (DICTIONARY_CACHE.has(text)) return (_DICTIONARY_CACHE_get = DICTIONARY_CACHE.get(text)) != null ? _DICTIONARY_CACHE_get : null;
+    let parsed = null;
+    try {
+        const value = JSON.parse(text);
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            parsed = value;
+        }
+    } catch (unused) {
+        parsed = null;
+    }
+    if (DICTIONARY_CACHE.size >= DICTIONARY_CACHE_MAX) {
+        const oldest = DICTIONARY_CACHE.keys().next().value;
+        if (oldest !== undefined) DICTIONARY_CACHE.delete(oldest);
+    }
+    DICTIONARY_CACHE.set(text, parsed);
+    return parsed;
+}
+/**
+ * `plan.annual`: a member of a DICTIONARY — a site variable of that type, or
+ * a text local holding one, which is how a function picks one of several
+ * ("the plan that won") and then reads its members.
+ *
+ * A site that prices six plans on twenty-five meters would otherwise need a
+ * hundred and fifty number variables, and the published page reads a
+ * hundred. One dictionary per plan is what an author would reach for anyway.
+ *
+ * OWN members only, and only a number, a text or a true/false comes out: a
+ * nested dictionary is walked by a longer path, never returned.
+ */ function readMember(path, scope) {
+    const [base, ...members] = path.split('.');
+    if (!Object.prototype.hasOwnProperty.call(scope, base)) {
+        throw new Error(`Unknown name "${base}"`);
+    }
+    let current = typeof scope[base] === 'string' ? parseDictionary(scope[base]) : null;
+    if (!current) throw new Error(`"${base}" is not a dictionary`);
+    for (const member of members){
+        if (!current || typeof current !== 'object' || Array.isArray(current) || !Object.prototype.hasOwnProperty.call(current, member)) {
+            throw new Error(`Unknown name "${path}"`);
+        }
+        current = current[member];
+    }
+    if (typeof current === 'number' || typeof current === 'string' || typeof current === 'boolean') {
+        return current;
+    }
+    throw new Error(`"${path}" is not a number, a text or a true/false`);
+}
+/** The built-in names, for an editor's help text and for tests. */ export const FUNCTION_BUILTIN_NAMES = Object.keys(BUILTINS);
+function isBuiltin(name) {
+    return Object.prototype.hasOwnProperty.call(BUILTINS, name);
+}
+/**
+ * The names an expression READS, in order, without evaluating it: every
+ * identifier that is not a built-in being called. Malformed text names
+ * nothing — the evaluator is where a bad expression is reported.
+ */ export function expressionIdentifiers(text) {
+    let tokens;
+    try {
+        tokens = tokenize(String(text != null ? text : ''));
+    } catch (unused) {
+        return [];
+    }
+    const names = [];
+    tokens.forEach((token, index)=>{
+        var _tokens_;
+        if (token.kind !== 'ident') return;
+        if (((_tokens_ = tokens[index + 1]) == null ? void 0 : _tokens_.kind) === 'lparen' && isBuiltin(token.value)) return;
+        // `plan_pro.annual` reads the variable `plan_pro`: the base is the name.
+        names.push(token.value.split('.')[0]);
+    });
+    return names;
+}
+/** Evaluates an expression against the scope. Throws on any invalid input. */ export function evaluateExpression(text, scope) {
+    const tokens = tokenize(text);
+    let position = 0;
+    const peek = ()=>tokens[position];
+    const next = ()=>tokens[position++];
+    function factor() {
+        const token = next();
+        if (!token) throw new Error('Unexpected end of expression');
+        if (token.kind === 'number' || token.kind === 'string' || token.kind === 'boolean') {
+            return token.value;
+        }
+        if (token.kind === 'ident') {
+            var _peek;
+            // A CALL, only when the parenthesis follows. A scope may still hold a
+            // value named `min` and read it as `min`, which is what every
+            // definition written before the built-ins existed relies on.
+            if (((_peek = peek()) == null ? void 0 : _peek.kind) === 'lparen') {
+                var _peek1;
+                if (!isBuiltin(token.value)) {
+                    throw new Error(`Unknown function "${token.value}"`);
+                }
+                next();
+                const args = [];
+                if (((_peek1 = peek()) == null ? void 0 : _peek1.kind) !== 'rparen') {
+                    var _peek2;
+                    args.push(expression());
+                    while(((_peek2 = peek()) == null ? void 0 : _peek2.kind) === 'comma'){
+                        next();
+                        args.push(expression());
+                    }
+                }
+                const closing = next();
+                if (!closing || closing.kind !== 'rparen') {
+                    throw new Error('Missing closing parenthesis');
+                }
+                return BUILTINS[token.value](args);
+            }
+            if (token.value.includes('.')) return readMember(token.value, scope);
+            // OWN properties only: `in` walks the prototype chain, so `toString`
+            // and `constructor` used to read as names every scope declared.
+            if (!Object.prototype.hasOwnProperty.call(scope, token.value)) {
+                throw new Error(`Unknown name "${token.value}"`);
+            }
+            return scope[token.value];
+        }
+        if (token.kind === 'lparen') {
+            const value = expression();
+            const closing = next();
+            if (!closing || closing.kind !== 'rparen') {
+                throw new Error('Missing closing parenthesis');
+            }
+            return value;
+        }
+        if (token.kind === 'op' && token.value === '-') {
+            return -toNumber(factor());
+        }
+        throw new Error('Unexpected token');
+    }
+    function term() {
+        var _peek;
+        let value = factor();
+        while(((_peek = peek()) == null ? void 0 : _peek.kind) === 'op' && [
+            '*',
+            '/'
+        ].includes(peek().value)){
+            const operator = next().value;
+            const right = toNumber(factor());
+            value = operator === '*' ? toNumber(value) * right : toNumber(value) / right;
+        }
+        return value;
+    }
+    function expression() {
+        var _peek;
+        let value = term();
+        while(((_peek = peek()) == null ? void 0 : _peek.kind) === 'op' && [
+            '+',
+            '-'
+        ].includes(peek().value)){
+            const operator = next().value;
+            const right = term();
+            if (operator === '+') {
+                // `+` concatenates when either side is a string, like the templates.
+                value = typeof value === 'string' || typeof right === 'string' ? String(value) + String(right) : toNumber(value) + toNumber(right);
+            } else {
+                value = toNumber(value) - toNumber(right);
+            }
+        }
+        return value;
+    }
+    const result = expression();
+    if (position < tokens.length) throw new Error('Unexpected trailing input');
+    return result;
+}
+function toNumber(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`"${value}" is not a number`);
+    }
+    return parsed;
+}
+function compare(left, comparator, right) {
+    switch(comparator){
+        case '==':
+            return left === right;
+        case '!=':
+            return left !== right;
+        case '<':
+            return toNumber(left) < toNumber(right);
+        case '<=':
+            return toNumber(left) <= toNumber(right);
+        case '>':
+            return toNumber(left) > toNumber(right);
+        case '>=':
+            return toNumber(left) >= toNumber(right);
+        default:
+            throw new Error(`Unknown comparator "${comparator}"`);
+    }
+}
+function defaultValue(type) {
+    return type === 'number' ? 0 : type === 'boolean' ? false : '';
+}
+function coerce(type, value) {
+    if (type === 'number') return toNumber(value);
+    if (type === 'boolean') return value === true || value === 'true';
+    return String(value != null ? value : '');
+}
+export function evaluateHostFunction(definition, args, options) {
+    try {
+        var _ref, _definition_parameters, _definition_variables, _definition_operations;
+        const scope = {};
+        for (const [name, value] of Object.entries((_ref = options == null ? void 0 : options.globals) != null ? _ref : {})){
+            scope[name] = value;
+        }
+        // What a SET may target: the function's own names, never a global.
+        const writable = new Set();
+        for (const parameter of (_definition_parameters = definition.parameters) != null ? _definition_parameters : []){
+            const provided = args[parameter.name];
+            const fallback = parameter.defaultValue;
+            if (provided == null || provided === '') {
+                if (fallback != null && fallback !== '') {
+                    scope[parameter.name] = coerce(parameter.type, fallback);
+                } else if (parameter.required) {
+                    throw new Error(`Parameter "${parameter.name}" is required`);
+                } else {
+                    scope[parameter.name] = defaultValue(parameter.type);
+                }
+            } else {
+                scope[parameter.name] = coerce(parameter.type, provided);
+            }
+            writable.add(parameter.name);
+        }
+        for (const variable of (_definition_variables = definition.variables) != null ? _definition_variables : []){
+            scope[variable.name] = defaultValue(variable.type);
+            writable.add(variable.name);
+        }
+        const operations = (_definition_operations = definition.operations) != null ? _definition_operations : [];
+        let applied = 0;
+        for (const operation of operations){
+            var _operation_then, _operation_otherwise;
+            const passed = compare(evaluateExpression(operation.if.left, scope), operation.if.comparator, evaluateExpression(operation.if.right, scope));
+            for (const setOperation of passed ? (_operation_then = operation.then) != null ? _operation_then : [] : (_operation_otherwise = operation.otherwise) != null ? _operation_otherwise : []){
+                if ((applied += 1) > FUNCTION_MAX_OPERATIONS) {
+                    throw new Error('Operation limit exceeded');
+                }
+                if (!writable.has(setOperation.set)) {
+                    throw new Error(Object.prototype.hasOwnProperty.call(scope, setOperation.set) ? `"${setOperation.set}" is a site variable: a function can ` + 'read it, not set it' : `Unknown variable "${setOperation.set}"`);
+                }
+                if (setOperation.workflow) {
+                    if (!(options == null ? void 0 : options.invokeWorkflow)) {
+                        throw new Error('Workflow calls are not available here');
+                    }
+                    scope[setOperation.set] = options.invokeWorkflow(setOperation.workflow, scope);
+                } else {
+                    scope[setOperation.set] = evaluateExpression(setOperation.expression, scope);
+                }
+            }
+        }
+        const returnName = definition.returnValue;
+        const value = returnName && Object.prototype.hasOwnProperty.call(scope, returnName) ? scope[returnName] : '';
+        return {
+            ok: true,
+            value,
+            scope
+        };
+    } catch (error) {
+        return {
+            ok: false,
+            error: error.message
+        };
+    }
+}
+/**
+ * The OUTSIDE names a function reads (AGL-3202): every identifier in its
+ * conditions and expressions that is not one of its own parameters or
+ * locals. Compose uses this to hand a Function Widget only the site
+ * variables its function asks for, so a published page never carries a
+ * variable nobody named.
+ */ export function functionReferencedNames(definition) {
+    var _definition_parameters, _definition_variables, _definition_operations;
+    const own = new Set([
+        ...((_definition_parameters = definition.parameters) != null ? _definition_parameters : []).map((parameter)=>parameter.name),
+        ...((_definition_variables = definition.variables) != null ? _definition_variables : []).map((variable)=>variable.name)
+    ]);
+    const names = new Set();
+    const read = (text)=>{
+        for (const name of expressionIdentifiers(String(text != null ? text : ''))){
+            if (!own.has(name)) names.add(name);
+        }
+    };
+    for (const operation of (_definition_operations = definition.operations) != null ? _definition_operations : []){
+        var _operation_then, _operation_otherwise;
+        var _operation_if, _operation_if1;
+        read((_operation_if = operation.if) == null ? void 0 : _operation_if.left);
+        read((_operation_if1 = operation.if) == null ? void 0 : _operation_if1.right);
+        for (const setOperation of [
+            ...(_operation_then = operation.then) != null ? _operation_then : [],
+            ...(_operation_otherwise = operation.otherwise) != null ? _operation_otherwise : []
+        ]){
+            read(setOperation.expression);
+        }
+    }
+    return [
+        ...names
+    ];
+}
+
+//# sourceMappingURL=functions.js.map

package/src/lib/app-utils/functions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/functions.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * No-code functions (Component Builder, AGL-92): the mockup's Edit Function\n * model — parameters, local variables, conditional SET operations, and a\n * return value — plus a small, safe expression evaluator. No eval(), no\n * loops, bounded operation count; expressions only reference declared\n * names, numeric/string/boolean literals, + - * / ( ), and the fixed table\n * of built-ins below.\n *\n * WHAT A REAL CALCULATOR NEEDED (AGL-3202). The first page built on this — a\n * cost sheet comparing five platforms — could compute its static table and\n * could not carry its interactive half, for three reasons that live here:\n *\n * - No `min`, no rounding, no number formatting. \"Cheapest of three plans\"\n *   took three compares, a per-site cost could not be shown at all, and\n *   \"$1,396\" was built by peeling thousands off with a ladder of six\n *   compares. {@link BUILTINS} closes that: a FIXED table, called as\n *   `name(args)`. Nothing a site author writes can add to it, so the\n *   evaluator's promise — no eval, no loops, bounded — is unchanged.\n * - A function could not read a site variable, so a widget's function had\n *   to repeat every price as a literal. `globals` on\n *   {@link EvaluateFunctionOptions} is that outer scope: readable, never\n *   settable, and shadowed by a parameter or local of the same name.\n * - A parameter was a bare identifier and a type. It may now carry what a\n *   visitor should see and start with: `label`, `options`, `defaultValue`.\n */\n\nexport type FunctionValueType = 'number' | 'text' | 'boolean'\n\n/** One entry of a parameter's choice list (AGL-3202). */\nexport interface HostFunctionParameterOption {\n  /** What the function receives; coerced to the parameter's type. */\n  value: string\n  /** What the visitor reads; the value when absent. */\n  label?: string\n}\n\n/**\n * A choice list as ONE line of text (AGL-3202):\n * `cms: A CMS and room to grow, entry: The entry plan only`. A bare entry is\n * both the value and what the visitor reads.\n *\n * One line, not a nested editor, because every surface that asks for choices\n * already asks for several other things in the same row. The cost is that a\n * value cannot itself contain a comma, and a label cannot either; a choice\n * that needs one is a sign the question wants rewording.\n *\n * In core because two plugins read it — the function builder that stores a\n * parameter's choices and the canvas element that offers its own — and a\n * plugin may not import another.\n */\nexport function parseFunctionParameterOptions(\n  text: string | null | undefined,\n): HostFunctionParameterOption[] {\n  const options: HostFunctionParameterOption[] = []\n  const seen = new Set<string>()\n  for (const part of String(text ?? '').split(',')) {\n    const colon = part.indexOf(':')\n    const value = (colon < 0 ? part : part.slice(0, colon)).trim()\n    // The second copy of a value is a typo, not a second choice: a select\n    // with two identical values cannot tell the function which was picked.\n    if (!value || seen.has(value)) continue\n    seen.add(value)\n    const label = colon < 0 ? '' : part.slice(colon + 1).trim()\n    options.push(label && label !== value ? { value, label } : { value })\n  }\n  return options\n}\n\n/** The inverse, for showing a stored list in that one line. */\nexport function formatFunctionParameterOptions(\n  options: HostFunctionParameterOption[] | null | undefined,\n): string {\n  return (options ?? [])\n    .map((option) =>\n      option.label && option.label !== option.value\n        ? `${option.value}: ${option.label}`\n        : option.value,\n    )\n    .join(', ')\n}\n\nexport interface HostFunctionParameter {\n  name: string\n  type: FunctionValueType\n  required?: boolean\n  /**\n   * What a visitor reads above the input (AGL-3202). The identifier is an\n   * authoring name — `client_sites` — and was the only label a Function\n   * Widget had.\n   */\n  label?: string\n  /**\n   * A fixed list to choose from; the widget renders a select. There is no\n   * other way to ASK a visitor for a choice: a free-text box that has to be\n   * typed into exactly is not a question.\n   */\n  options?: HostFunctionParameterOption[]\n  /**\n   * What the input starts with, and what an empty input evaluates as. It\n   * satisfies `required`: a parameter with a default is never missing.\n   */\n  defaultValue?: string\n}\n\nexport interface HostFunctionVariable {\n  name: string\n  type: FunctionValueType\n}\n\nexport type FunctionComparator = '==' | '!=' | '<' | '<=' | '>' | '>='\n\nexport interface FunctionSetOperation {\n  /** Variable (or parameter) name receiving the value. */\n  set: string\n  /** Expression text, e.g. `P1 + P2` or `(P1 + 1) * 2`. */\n  expression: string\n  /**\n   * Workflow (by name) whose result to assign instead of `expression`\n   * (AGL-129). Runs with the function's current scope visible; only\n   * honored when the caller provides a workflow runner.\n   */\n  workflow?: string\n}\n\n/** The mockup's numbered operation card: if / then / otherwise. */\nexport interface FunctionConditionalOperation {\n  if: { left: string; comparator: FunctionComparator; right: string }\n  then: FunctionSetOperation[]\n  otherwise: FunctionSetOperation[]\n}\n\n/** `hosts/{hostId}/functions/{id}` doc. */\nexport interface HostFunction {\n  name: string\n  parameters: HostFunctionParameter[]\n  variables: HostFunctionVariable[]\n  operations: FunctionConditionalOperation[]\n  /** Name whose final value the function returns. */\n  returnValue?: string\n}\n\n/**\n * How many SETs one run may apply. A BOUND, not a budget anyone is meant to\n * approach: there are no loops, so a run applies at most one SET per SET\n * written, and this is what stops a definition pasted in by the thousand.\n *\n * It was 100, sized for \"if P1 <= P2 then P3 = P1 + P2\". The first pricing\n * calculator built on site functions — six plans, a line per meter, a row per\n * competitor — applies about 150 (AGL-3202). Each SET is one short expression\n * over a flat scope, so a thousand of them is still well under a millisecond.\n */\nexport const FUNCTION_MAX_OPERATIONS = 1000\n\ntype Scope = Record<string, number | string | boolean>\n\n// ── Expression parsing (recursive descent, standard precedence) ────────────\n\ntype Token =\n  | { kind: 'number'; value: number }\n  | { kind: 'string'; value: string }\n  | { kind: 'boolean'; value: boolean }\n  | { kind: 'ident'; value: string }\n  | { kind: 'op'; value: '+' | '-' | '*' | '/' }\n  | { kind: 'lparen' }\n  | { kind: 'rparen' }\n  | { kind: 'comma' }\n\nfunction tokenize(text: string): Token[] {\n  const tokens: Token[] = []\n  let index = 0\n  while (index < text.length) {\n    const char = text[index]\n    if (/\\s/.test(char)) {\n      index += 1\n    } else if ('+-*/'.includes(char)) {\n      tokens.push({ kind: 'op', value: char as any })\n      index += 1\n    } else if (char === '(') {\n      tokens.push({ kind: 'lparen' })\n      index += 1\n    } else if (char === ')') {\n      tokens.push({ kind: 'rparen' })\n      index += 1\n    } else if (char === ',') {\n      // Only meaningful between a built-in's arguments; anywhere else the\n      // parser reports it as trailing input.\n      tokens.push({ kind: 'comma' })\n      index += 1\n    } else if (char === \"'\" || char === '\"') {\n      const end = text.indexOf(char, index + 1)\n      if (end < 0) throw new Error('Unterminated string')\n      tokens.push({ kind: 'string', value: text.slice(index + 1, end) })\n      index = end + 1\n    } else if (/[0-9.]/.test(char)) {\n      const match = /^[0-9]*\\.?[0-9]+/.exec(text.slice(index))\n      if (!match) throw new Error(`Bad number at \"${text.slice(index)}\"`)\n      tokens.push({ kind: 'number', value: Number(match[0]) })\n      index += match[0].length\n    } else if (/[a-zA-Z_]/.test(char)) {\n      // A dotted path is ONE name: `plan_pro.annual` reads a member of a\n      // dictionary (AGL-3202). A number never starts here, so `1.5` is not\n      // at risk, and a trailing dot is left for the parser to refuse.\n      const match = /^[a-zA-Z_][a-zA-Z0-9_]*(?:\\.[a-zA-Z_][a-zA-Z0-9_]*)*/.exec(\n        text.slice(index),\n      )!\n      const word = match[0]\n      if (word === 'true' || word === 'false') {\n        tokens.push({ kind: 'boolean', value: word === 'true' })\n      } else {\n        tokens.push({ kind: 'ident', value: word })\n      }\n      index += word.length\n    } else {\n      throw new Error(`Unexpected character \"${char}\"`)\n    }\n  }\n  return tokens\n}\n\n// ── Built-ins (AGL-3202) ───────────────────────────────────────────────────\n\ntype Value = number | string | boolean\n\n/** More arguments than any built-in can use; a typo, not a calculation. */\nconst MAX_CALL_ARGUMENTS = 16\n/** Decimal places `round` and `format` accept. */\nconst MAX_DIGITS = 10\n\nfunction digitsOf(value: Value | undefined): number {\n  if (value === undefined) return 0\n  const digits = Math.trunc(toNumber(value))\n  if (digits < 0 || digits > MAX_DIGITS) {\n    throw new Error(`Decimal places must be between 0 and ${MAX_DIGITS}`)\n  }\n  return digits\n}\n\n/**\n * Half away from zero, on the DECIMAL value. The exponent form is what makes\n * `round(1.005, 2)` answer 1.01: multiplying by 100 first gives\n * 100.49999999999999 and rounds it down.\n */\nfunction roundTo(value: number, digits: number): number {\n  const magnitude = Number(\n    `${Math.round(Number(`${Math.abs(value)}e${digits}`))}e-${digits}`,\n  )\n  return value < 0 ? -magnitude : magnitude\n}\n\nfunction arity(name: string, args: Value[], least: number, most: number): void {\n  if (args.length < least || args.length > most) {\n    const wanted = least === most ? `${least}` : `${least} to ${most}`\n    throw new Error(`${name}() takes ${wanted} argument(s)`)\n  }\n}\n\n/**\n * THE WHOLE TABLE, and it is closed. A site author calls these; nothing they\n * write can add one, and none of them loops, allocates by input size or\n * reaches outside its arguments.\n *\n * `format` is pinned to `en-US` on purpose. The same function runs on the\n * server for a `{{fn:…}}` token and in a visitor's browser for a widget, and\n * the machine's own locale would make those two disagree about \"1,396\".\n */\nconst BUILTINS: Record<string, (args: Value[]) => Value> = {\n  min: (args) => {\n    arity('min', args, 1, MAX_CALL_ARGUMENTS)\n    return Math.min(...args.map(toNumber))\n  },\n  max: (args) => {\n    arity('max', args, 1, MAX_CALL_ARGUMENTS)\n    return Math.max(...args.map(toNumber))\n  },\n  round: (args) => {\n    arity('round', args, 1, 2)\n    return roundTo(toNumber(args[0]), digitsOf(args[1]))\n  },\n  floor: (args) => {\n    arity('floor', args, 1, 1)\n    return Math.floor(toNumber(args[0]))\n  },\n  ceil: (args) => {\n    arity('ceil', args, 1, 1)\n    return Math.ceil(toNumber(args[0]))\n  },\n  abs: (args) => {\n    arity('abs', args, 1, 1)\n    return Math.abs(toNumber(args[0]))\n  },\n  format: (args) => {\n    arity('format', args, 1, 2)\n    const digits = digitsOf(args[1])\n    return roundTo(toNumber(args[0]), digits).toLocaleString('en-US', {\n      minimumFractionDigits: digits,\n      maximumFractionDigits: digits,\n    })\n  },\n}\n\n// ── Dictionary members (AGL-3202) ──────────────────────────────────────────\n\n/**\n * Parsed dictionaries, by their JSON text. A pricing function reads thirty\n * members of the same six dictionaries on every keystroke, and the text is\n * the only identity a scope value has. Small and bounded: a page holds a\n * handful of dictionaries, and a miss only costs a parse.\n */\nconst DICTIONARY_CACHE = new Map<string, Record<string, unknown> | null>()\nconst DICTIONARY_CACHE_MAX = 64\n\nfunction parseDictionary(text: string): Record<string, unknown> | null {\n  if (DICTIONARY_CACHE.has(text)) return DICTIONARY_CACHE.get(text) ?? null\n  let parsed: Record<string, unknown> | null = null\n  try {\n    const value: unknown = JSON.parse(text)\n    if (value && typeof value === 'object' && !Array.isArray(value)) {\n      parsed = value as Record<string, unknown>\n    }\n  } catch {\n    parsed = null\n  }\n  if (DICTIONARY_CACHE.size >= DICTIONARY_CACHE_MAX) {\n    const oldest = DICTIONARY_CACHE.keys().next().value\n    if (oldest !== undefined) DICTIONARY_CACHE.delete(oldest)\n  }\n  DICTIONARY_CACHE.set(text, parsed)\n  return parsed\n}\n\n/**\n * `plan.annual`: a member of a DICTIONARY — a site variable of that type, or\n * a text local holding one, which is how a function picks one of several\n * (\"the plan that won\") and then reads its members.\n *\n * A site that prices six plans on twenty-five meters would otherwise need a\n * hundred and fifty number variables, and the published page reads a\n * hundred. One dictionary per plan is what an author would reach for anyway.\n *\n * OWN members only, and only a number, a text or a true/false comes out: a\n * nested dictionary is walked by a longer path, never returned.\n */\nfunction readMember(path: string, scope: Scope): Value {\n  const [base, ...members] = path.split('.')\n  if (!Object.prototype.hasOwnProperty.call(scope, base)) {\n    throw new Error(`Unknown name \"${base}\"`)\n  }\n  let current: unknown =\n    typeof scope[base] === 'string' ? parseDictionary(scope[base] as string) : null\n  if (!current) throw new Error(`\"${base}\" is not a dictionary`)\n  for (const member of members) {\n    if (\n      !current ||\n      typeof current !== 'object' ||\n      Array.isArray(current) ||\n      !Object.prototype.hasOwnProperty.call(current, member)\n    ) {\n      throw new Error(`Unknown name \"${path}\"`)\n    }\n    current = (current as Record<string, unknown>)[member]\n  }\n  if (\n    typeof current === 'number' ||\n    typeof current === 'string' ||\n    typeof current === 'boolean'\n  ) {\n    return current\n  }\n  throw new Error(`\"${path}\" is not a number, a text or a true/false`)\n}\n\n/** The built-in names, for an editor's help text and for tests. */\nexport const FUNCTION_BUILTIN_NAMES: readonly string[] = Object.keys(BUILTINS)\n\nfunction isBuiltin(name: string): boolean {\n  return Object.prototype.hasOwnProperty.call(BUILTINS, name)\n}\n\n/**\n * The names an expression READS, in order, without evaluating it: every\n * identifier that is not a built-in being called. Malformed text names\n * nothing — the evaluator is where a bad expression is reported.\n */\nexport function expressionIdentifiers(text: string): string[] {\n  let tokens: Token[]\n  try {\n    tokens = tokenize(String(text ?? ''))\n  } catch {\n    return []\n  }\n  const names: string[] = []\n  tokens.forEach((token, index) => {\n    if (token.kind !== 'ident') return\n    if (tokens[index + 1]?.kind === 'lparen' && isBuiltin(token.value)) return\n    // `plan_pro.annual` reads the variable `plan_pro`: the base is the name.\n    names.push(token.value.split('.')[0])\n  })\n  return names\n}\n\n/** Evaluates an expression against the scope. Throws on any invalid input. */\nexport function evaluateExpression(\n  text: string,\n  scope: Scope,\n): number | string | boolean {\n  const tokens = tokenize(text)\n  let position = 0\n\n  const peek = () => tokens[position]\n  const next = () => tokens[position++]\n\n  function factor(): number | string | boolean {\n    const token = next()\n    if (!token) throw new Error('Unexpected end of expression')\n    if (token.kind === 'number' || token.kind === 'string' || token.kind === 'boolean') {\n      return token.value\n    }\n    if (token.kind === 'ident') {\n      // A CALL, only when the parenthesis follows. A scope may still hold a\n      // value named `min` and read it as `min`, which is what every\n      // definition written before the built-ins existed relies on.\n      if (peek()?.kind === 'lparen') {\n        if (!isBuiltin(token.value)) {\n          throw new Error(`Unknown function \"${token.value}\"`)\n        }\n        next()\n        const args: Value[] = []\n        if (peek()?.kind !== 'rparen') {\n          args.push(expression())\n          while (peek()?.kind === 'comma') {\n            next()\n            args.push(expression())\n          }\n        }\n        const closing = next()\n        if (!closing || closing.kind !== 'rparen') {\n          throw new Error('Missing closing parenthesis')\n        }\n        return BUILTINS[token.value](args)\n      }\n      if (token.value.includes('.')) return readMember(token.value, scope)\n      // OWN properties only: `in` walks the prototype chain, so `toString`\n      // and `constructor` used to read as names every scope declared.\n      if (!Object.prototype.hasOwnProperty.call(scope, token.value)) {\n        throw new Error(`Unknown name \"${token.value}\"`)\n      }\n      return scope[token.value]\n    }\n    if (token.kind === 'lparen') {\n      const value = expression()\n      const closing = next()\n      if (!closing || closing.kind !== 'rparen') {\n        throw new Error('Missing closing parenthesis')\n      }\n      return value\n    }\n    if (token.kind === 'op' && token.value === '-') {\n      return -toNumber(factor())\n    }\n    throw new Error('Unexpected token')\n  }\n\n  function term(): number | string | boolean {\n    let value = factor()\n    while (peek()?.kind === 'op' && ['*', '/'].includes((peek() as any).value)) {\n      const operator = (next() as any).value\n      const right = toNumber(factor())\n      value =\n        operator === '*' ? toNumber(value) * right : toNumber(value) / right\n    }\n    return value\n  }\n\n  function expression(): number | string | boolean {\n    let value = term()\n    while (peek()?.kind === 'op' && ['+', '-'].includes((peek() as any).value)) {\n      const operator = (next() as any).value\n      const right = term()\n      if (operator === '+') {\n        // `+` concatenates when either side is a string, like the templates.\n        value =\n          typeof value === 'string' || typeof right === 'string'\n            ? String(value) + String(right)\n            : toNumber(value) + toNumber(right)\n      } else {\n        value = toNumber(value) - toNumber(right)\n      }\n    }\n    return value\n  }\n\n  const result = expression()\n  if (position < tokens.length) throw new Error('Unexpected trailing input')\n  return result\n}\n\nfunction toNumber(value: unknown): number {\n  const parsed = Number(value)\n  if (!Number.isFinite(parsed)) {\n    throw new Error(`\"${value}\" is not a number`)\n  }\n  return parsed\n}\n\nfunction compare(\n  left: number | string | boolean,\n  comparator: FunctionComparator,\n  right: number | string | boolean,\n): boolean {\n  switch (comparator) {\n    case '==':\n      return left === right\n    case '!=':\n      return left !== right\n    case '<':\n      return toNumber(left) < toNumber(right)\n    case '<=':\n      return toNumber(left) <= toNumber(right)\n    case '>':\n      return toNumber(left) > toNumber(right)\n    case '>=':\n      return toNumber(left) >= toNumber(right)\n    default:\n      throw new Error(`Unknown comparator \"${comparator}\"`)\n  }\n}\n\nfunction defaultValue(type: FunctionValueType): number | string | boolean {\n  return type === 'number' ? 0 : type === 'boolean' ? false : ''\n}\n\nfunction coerce(\n  type: FunctionValueType,\n  value: unknown,\n): number | string | boolean {\n  if (type === 'number') return toNumber(value)\n  if (type === 'boolean') return value === true || value === 'true'\n  return String(value ?? '')\n}\n\nexport type FunctionRunResult =\n  | { ok: true; value: number | string | boolean; scope: Scope }\n  | { ok: false; error: string }\n\n/**\n * Runs a function definition against arguments: parameters coerce/validate\n * into scope, variables initialize to type defaults, each conditional\n * evaluates its `if` and applies the matching SET list in order, and the\n * `returnValue` name's final value comes back.\n */\nexport interface EvaluateFunctionOptions {\n  /**\n   * Workflow invoker for `set.workflow` operations (AGL-129); wired by\n   * `runWorkflow` so cross-calls share one depth guard. Absent means\n   * workflow operations fail with a clear error.\n   */\n  invokeWorkflow?: (\n    name: string,\n    scope: Scope,\n  ) => number | string | boolean\n  /**\n   * Site variables by NAME (AGL-3202): the scope outside the function.\n   *\n   * READ-ONLY, and the function's own names win. A parameter or local of the\n   * same name shadows the variable, so adding a site variable can never\n   * change what an existing function computes; and a SET may only target a\n   * parameter or a local, so a function cannot appear to change a value that\n   * every other page reads.\n   */\n  globals?: Scope\n}\n\nexport function evaluateHostFunction(\n  definition: HostFunction,\n  args: Record<string, unknown>,\n  options?: EvaluateFunctionOptions,\n): FunctionRunResult {\n  try {\n    const scope: Scope = {}\n    for (const [name, value] of Object.entries(options?.globals ?? {})) {\n      scope[name] = value\n    }\n    // What a SET may target: the function's own names, never a global.\n    const writable = new Set<string>()\n    for (const parameter of definition.parameters ?? []) {\n      const provided = args[parameter.name]\n      const fallback = parameter.defaultValue\n      if (provided == null || provided === '') {\n        if (fallback != null && fallback !== '') {\n          scope[parameter.name] = coerce(parameter.type, fallback)\n        } else if (parameter.required) {\n          throw new Error(`Parameter \"${parameter.name}\" is required`)\n        } else {\n          scope[parameter.name] = defaultValue(parameter.type)\n        }\n      } else {\n        scope[parameter.name] = coerce(parameter.type, provided)\n      }\n      writable.add(parameter.name)\n    }\n    for (const variable of definition.variables ?? []) {\n      scope[variable.name] = defaultValue(variable.type)\n      writable.add(variable.name)\n    }\n\n    const operations = definition.operations ?? []\n    let applied = 0\n    for (const operation of operations) {\n      const passed = compare(\n        evaluateExpression(operation.if.left, scope),\n        operation.if.comparator,\n        evaluateExpression(operation.if.right, scope),\n      )\n      for (const setOperation of passed\n        ? (operation.then ?? [])\n        : (operation.otherwise ?? [])) {\n        if ((applied += 1) > FUNCTION_MAX_OPERATIONS) {\n          throw new Error('Operation limit exceeded')\n        }\n        if (!writable.has(setOperation.set)) {\n          throw new Error(\n            Object.prototype.hasOwnProperty.call(scope, setOperation.set)\n              ? `\"${setOperation.set}\" is a site variable: a function can ` +\n                  'read it, not set it'\n              : `Unknown variable \"${setOperation.set}\"`,\n          )\n        }\n        if (setOperation.workflow) {\n          if (!options?.invokeWorkflow) {\n            throw new Error('Workflow calls are not available here')\n          }\n          scope[setOperation.set] = options.invokeWorkflow(\n            setOperation.workflow,\n            scope,\n          )\n        } else {\n          scope[setOperation.set] = evaluateExpression(\n            setOperation.expression,\n            scope,\n          )\n        }\n      }\n    }\n\n    const returnName = definition.returnValue\n    const value =\n      returnName && Object.prototype.hasOwnProperty.call(scope, returnName)\n        ? scope[returnName]\n        : ''\n    return { ok: true, value, scope }\n  } catch (error) {\n    return { ok: false, error: (error as Error).message }\n  }\n}\n\n/**\n * The OUTSIDE names a function reads (AGL-3202): every identifier in its\n * conditions and expressions that is not one of its own parameters or\n * locals. Compose uses this to hand a Function Widget only the site\n * variables its function asks for, so a published page never carries a\n * variable nobody named.\n */\nexport function functionReferencedNames(definition: HostFunction): string[] {\n  const own = new Set<string>([\n    ...(definition.parameters ?? []).map((parameter) => parameter.name),\n    ...(definition.variables ?? []).map((variable) => variable.name),\n  ])\n  const names = new Set<string>()\n  const read = (text: unknown) => {\n    for (const name of expressionIdentifiers(String(text ?? ''))) {\n      if (!own.has(name)) names.add(name)\n    }\n  }\n  for (const operation of definition.operations ?? []) {\n    read(operation.if?.left)\n    read(operation.if?.right)\n    for (const setOperation of [\n      ...(operation.then ?? []),\n      ...(operation.otherwise ?? []),\n    ]) {\n      read(setOperation.expression)\n    }\n  }\n  return [...names]\n}\n"],"names":["parseFunctionParameterOptions","text","options","seen","Set","part","String","split","colon","indexOf","value","slice","trim","has","add","label","push","formatFunctionParameterOptions","map","option","join","FUNCTION_MAX_OPERATIONS","tokenize","tokens","index","length","char","test","includes","kind","end","Error","match","exec","Number","word","MAX_CALL_ARGUMENTS","MAX_DIGITS","digitsOf","undefined","digits","Math","trunc","toNumber","roundTo","magnitude","round","abs","arity","name","args","least","most","wanted","BUILTINS","min","max","floor","ceil","format","toLocaleString","minimumFractionDigits","maximumFractionDigits","DICTIONARY_CACHE","Map","DICTIONARY_CACHE_MAX","parseDictionary","get","parsed","JSON","parse","Array","isArray","size","oldest","keys","next","delete","set","readMember","path","scope","base","members","Object","prototype","hasOwnProperty","call","current","member","FUNCTION_BUILTIN_NAMES","isBuiltin","expressionIdentifiers","names","forEach","token","evaluateExpression","position","peek","factor","expression","closing","term","operator","right","result","isFinite","compare","left","comparator","defaultValue","type","coerce","evaluateHostFunction","definition","entries","globals","writable","parameter","parameters","provided","fallback","required","variable","variables","operations","applied","operation","passed","if","setOperation","then","otherwise","workflow","invokeWorkflow","returnName","returnValue","ok","error","message","functionReferencedNames","own","read"],"mappings":"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"}