spl-lang 0.0.0-stage → 0.1.0

package/dist/restrict.d.ts

@@ -0,0 +1,27 @@
+import type { RestrictKind } from './ast.js';
+export interface Restriction {
+    kind: RestrictKind;
+    /** fs: canonical absolute directories; net: lowercase hosts (may be `*.x`); exec: executable names. */
+    values: string[];
+}
+/** Resolves symlinks of the nearest existing ancestor so `..` and links cannot escape a folder. */
+export declare function canonicalPath(p: string, cwd: string, depth?: number): string;
+export declare function normalizeHost(entry: string): string;
+export declare function normalizeExec(name: string): string;
+/** Immutable snapshot of the active `restrict` scopes. Every kind present narrows (intersects). */
+export declare class Restrictions {
+    private readonly cwd;
+    readonly list: readonly Restriction[];
+    constructor(cwd: string, list?: readonly Restriction[]);
+    with(r: Restriction): Restrictions;
+    get active(): boolean;
+    has(kind: RestrictKind): boolean;
+    checkPath(p: string, action?: 'read' | 'write'): string;
+    checkUrl(url: string): URL;
+    checkHost(host: string): void;
+    checkExec(name: string): void;
+    /** Human-readable guidance for the LLM (the first enforcement layer). */
+    guidance(): string[];
+}
+/** Builds a normalized restriction from the script-provided string ("a,b") or list of strings. */
+export declare function makeRestriction(kind: RestrictKind, raw: unknown, cwd: string): Restriction;

package/dist/restrict.js

@@ -0,0 +1,158 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Failure } from './errors.js';
+const IS_WINDOWS = process.platform === 'win32';
+const violation = (msg) => new Failure('restriction_violation', msg);
+/** Resolves symlinks of the nearest existing ancestor so `..` and links cannot escape a folder. */
+export function canonicalPath(p, cwd, depth = 0) {
+    if (depth > 32)
+        throw violation(`too many symbolic links while resolving '${p}'`);
+    const abs = path.resolve(cwd, p);
+    const rest = [];
+    let cur = abs;
+    for (;;) {
+        try {
+            const real = fs.realpathSync.native(cur);
+            return path.join(real, ...rest.reverse());
+        }
+        catch (e) {
+            const code = e.code;
+            if (code !== 'ENOENT' && code !== 'ENOTDIR') {
+                throw violation(`cannot resolve path '${p}': ${e.message}`);
+            }
+            // A dangling symlink must be followed too: writing through it would create its target.
+            let link;
+            try {
+                if (fs.lstatSync(cur).isSymbolicLink())
+                    link = fs.readlinkSync(cur);
+            }
+            catch {
+                link = undefined;
+            }
+            if (link !== undefined) {
+                const target = canonicalPath(path.resolve(path.dirname(cur), link), cwd, depth + 1);
+                return path.join(target, ...rest.reverse());
+            }
+            const parent = path.dirname(cur);
+            if (parent === cur)
+                return abs;
+            rest.push(path.basename(cur));
+            cur = parent;
+        }
+    }
+}
+const fold = (p) => (IS_WINDOWS ? p.toLowerCase() : p);
+function isInside(target, root) {
+    const rel = path.relative(fold(root), fold(target));
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+export function normalizeHost(entry) {
+    let e = entry.trim().toLowerCase();
+    if (e.includes('://')) {
+        try {
+            e = new URL(e).hostname;
+        }
+        catch {
+            throw violation(`invalid host '${entry}' in restrict net`);
+        }
+    }
+    return e.replace(/:\d+$/, '');
+}
+export function normalizeExec(name) {
+    let n = path.basename(name.trim().replace(/\\/g, '/'));
+    if (IS_WINDOWS)
+        n = n.toLowerCase().replace(/\.(exe|cmd|bat|com)$/, '');
+    return n;
+}
+function hostAllowed(host, allowed) {
+    return allowed.some((a) => host === a || (a.startsWith('*.') && host.endsWith(a.slice(1))));
+}
+/** Immutable snapshot of the active `restrict` scopes. Every kind present narrows (intersects). */
+export class Restrictions {
+    cwd;
+    list;
+    constructor(cwd, list = []) {
+        this.cwd = cwd;
+        this.list = list;
+    }
+    with(r) {
+        return new Restrictions(this.cwd, [...this.list, r]);
+    }
+    get active() {
+        return this.list.length > 0;
+    }
+    has(kind) {
+        return this.list.some((r) => r.kind === kind);
+    }
+    checkPath(p, action = 'read') {
+        const canonical = canonicalPath(p, this.cwd);
+        for (const r of this.list) {
+            if (r.kind === 'fs' && !r.values.some((root) => isInside(canonical, root))) {
+                throw violation(`${action} of '${canonical}' blocked: outside allowed folder(s) ${r.values.join(', ')}`);
+            }
+        }
+        return canonical;
+    }
+    checkUrl(url) {
+        let u;
+        try {
+            u = new URL(url);
+        }
+        catch {
+            throw new Failure('tool_error', `invalid URL '${url}'`);
+        }
+        if (u.protocol !== 'http:' && u.protocol !== 'https:') {
+            throw new Failure('tool_error', `unsupported URL scheme '${u.protocol}'`);
+        }
+        this.checkHost(u.hostname.toLowerCase());
+        return u;
+    }
+    checkHost(host) {
+        for (const r of this.list) {
+            if (r.kind === 'net' && !hostAllowed(host, r.values)) {
+                throw violation(`network access to '${host}' blocked: allowed hosts are ${r.values.join(', ')}`);
+            }
+        }
+    }
+    checkExec(name) {
+        const n = normalizeExec(name);
+        for (const r of this.list) {
+            if (r.kind !== 'exec')
+                continue;
+            if (/[\\/]/.test(name.trim())) {
+                throw violation(`executable '${name}' blocked: inside a restrict exec block executables must be named without a path`);
+            }
+            if (!r.values.includes(n)) {
+                throw violation(`executable '${n}' blocked: allowed executables are ${r.values.join(', ')}`);
+            }
+        }
+    }
+    /** Human-readable guidance for the LLM (the first enforcement layer). */
+    guidance() {
+        return this.list.map((r) => {
+            if (r.kind === 'fs')
+                return `File system: you may read and write only inside: ${r.values.join(', ')}. Any other path will be blocked.`;
+            if (r.kind === 'net')
+                return `Network: you may only access these hosts: ${r.values.join(', ')}. Any other host will be blocked.`;
+            return `Shell: you may only run these executables: ${r.values.join(', ')}, one simple command at a time (no pipes, redirects or chaining). Anything else will be blocked.`;
+        });
+    }
+}
+/** Builds a normalized restriction from the script-provided string ("a,b") or list of strings. */
+export function makeRestriction(kind, raw, cwd) {
+    let items;
+    if (typeof raw === 'string')
+        items = raw.split(',');
+    else if (Array.isArray(raw) && raw.every((x) => typeof x === 'string'))
+        items = raw.flatMap((x) => x.split(','));
+    else
+        throw new Failure('runtime_error', `restrict ${kind} expects a string (comma-separated) or a list of strings`);
+    items = items.map((s) => s.trim()).filter((s) => s.length > 0);
+    if (items.length === 0)
+        throw new Failure('runtime_error', `restrict ${kind} needs at least one entry`);
+    if (kind === 'fs')
+        return { kind, values: [...new Set(items.map((i) => canonicalPath(i, cwd)))] };
+    if (kind === 'net')
+        return { kind, values: [...new Set(items.map(normalizeHost))] };
+    return { kind, values: [...new Set(items.map(normalizeExec))] };
+}

package/dist/store.d.ts

@@ -0,0 +1,20 @@
+import { type Value } from './values.js';
+/** Pluggable persistence for top-level variables. */
+export interface VariableStore {
+    /** Variables persisted by a previous run; they seed the global scope. */
+    load(): Record<string, Value>;
+    /** Persists a snapshot of all top-level variables. */
+    save(vars: Record<string, Value>): void;
+}
+export declare class MemoryStore implements VariableStore {
+    load(): Record<string, Value>;
+    save(): void;
+}
+export declare class JsonFileStore implements VariableStore {
+    private readonly file;
+    constructor(file: string);
+    load(): Record<string, Value>;
+    save(vars: Record<string, Value>): void;
+}
+/** Loads a custom store from a module exporting `createStore(): VariableStore` (or a default export of the same shape). */
+export declare function loadStoreModule(spec: string): Promise<VariableStore>;

package/dist/store.js

@@ -0,0 +1,52 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { fromJson, isFunction, toJson } from './values.js';
+export class MemoryStore {
+    load() {
+        return {};
+    }
+    save() { }
+}
+export class JsonFileStore {
+    file;
+    constructor(file) {
+        this.file = file;
+    }
+    load() {
+        if (!fs.existsSync(this.file))
+            return {};
+        const raw = fs.readFileSync(this.file, 'utf8');
+        if (raw.trim() === '')
+            return {};
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            throw new Error(`variable store '${this.file}' must contain a JSON object`);
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(parsed))
+            out[k] = fromJson(v);
+        return out;
+    }
+    save(vars) {
+        const data = {};
+        for (const [k, v] of Object.entries(vars))
+            if (!isFunction(v))
+                data[k] = toJson(v);
+        fs.mkdirSync(path.dirname(path.resolve(this.file)), { recursive: true });
+        const tmp = `${this.file}.${process.pid}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf8');
+        fs.renameSync(tmp, this.file);
+    }
+}
+/** Loads a custom store from a module exporting `createStore(): VariableStore` (or a default export of the same shape). */
+export async function loadStoreModule(spec) {
+    const url = spec.startsWith('.') || path.isAbsolute(spec) ? pathToFileURL(path.resolve(spec)).href : spec;
+    const mod = (await import(url));
+    const factory = mod.createStore ?? (typeof mod.default === 'function' ? mod.default : undefined);
+    const store = factory ? await factory() : mod.default;
+    if (!store || typeof store.load !== 'function' || typeof store.save !== 'function') {
+        throw new Error(`store module '${spec}' must export createStore() returning { load(), save() }`);
+    }
+    return store;
+}

package/dist/tools.d.ts

@@ -0,0 +1,38 @@
+import type { ToolName } from './ast.js';
+import type { Restrictions } from './restrict.js';
+export interface ToolSpec {
+    name: ToolName;
+    description: string;
+    properties: Record<string, {
+        type: 'string';
+        description: string;
+    }>;
+    required: string[];
+}
+export declare const TOOL_SPECS: Record<ToolName, ToolSpec>;
+/** Splits a simple command line, honoring '...' and "..." quoting. No escapes, no expansion. */
+export declare function splitCommand(command: string): string[];
+export interface SearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+}
+/** Extracts result links from DuckDuckGo's HTML results page; result links are redirects carrying the target in `uddg`. */
+export declare function parseSearchResults(html: string): SearchResult[];
+/**
+ * Executes the built-in tools. Every call is checked against the active restrictions,
+ * whether it comes from the script itself or from the LLM.
+ */
+export declare class ToolHost {
+    private readonly restrictions;
+    private readonly cwd;
+    constructor(restrictions: Restrictions, cwd: string);
+    invoke(name: ToolName, params: Record<string, unknown>): Promise<string>;
+    private readFile;
+    private writeFile;
+    private webFetch;
+    /** Searches DuckDuckGo's HTML endpoint (no API key); it is a network call, so `restrict net` applies to it. */
+    private webSearch;
+    private shell;
+    private run;
+}

package/dist/tools.js

@@ -0,0 +1,266 @@
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { Failure } from './errors.js';
+const MAX_TEXT = 200_000;
+const SHELL_TIMEOUT_MS = 120_000;
+const FETCH_TIMEOUT_MS = 30_000;
+const MAX_REDIRECTS = 5;
+/** Characters that let a command chain, redirect or substitute; rejected while any restriction is active. */
+const SHELL_META = /[&|;<>`$()\r\n^%!]/;
+export const TOOL_SPECS = {
+    read_file: {
+        name: 'read_file',
+        description: 'Read a UTF-8 text file and return its content.',
+        properties: { path: { type: 'string', description: 'Path of the file to read' } },
+        required: ['path'],
+    },
+    write_file: {
+        name: 'write_file',
+        description: 'Create or overwrite a UTF-8 text file (parent folders are created).',
+        properties: {
+            path: { type: 'string', description: 'Path of the file to write' },
+            content: { type: 'string', description: 'Complete new content of the file' },
+        },
+        required: ['path', 'content'],
+    },
+    web_fetch: {
+        name: 'web_fetch',
+        description: 'Fetch an http(s) URL with GET and return the response body as text.',
+        properties: { url: { type: 'string', description: 'URL to fetch' } },
+        required: ['url'],
+    },
+    web_search: {
+        name: 'web_search',
+        description: 'Search the web and return the top results (title, URL and snippet).',
+        properties: { query: { type: 'string', description: 'Search query' } },
+        required: ['query'],
+    },
+    shell: {
+        name: 'shell',
+        description: 'Run a shell command and return its combined output.',
+        properties: { command: { type: 'string', description: 'Command line to run' } },
+        required: ['command'],
+    },
+};
+function needString(tool, params, name) {
+    const v = params[name];
+    if (typeof v !== 'string' || v === '')
+        throw new Failure('tool_error', `${tool}: parameter '${name}' must be a non-empty string`);
+    return v;
+}
+function truncate(text) {
+    return text.length > MAX_TEXT ? `${text.slice(0, MAX_TEXT)}\n...[truncated ${text.length - MAX_TEXT} characters]` : text;
+}
+/** Splits a simple command line, honoring '...' and "..." quoting. No escapes, no expansion. */
+export function splitCommand(command) {
+    const args = [];
+    let cur = '';
+    let inToken = false;
+    let quote;
+    for (const ch of command) {
+        if (quote) {
+            if (ch === quote)
+                quote = undefined;
+            else
+                cur += ch;
+        }
+        else if (ch === '"' || ch === "'") {
+            quote = ch;
+            inToken = true;
+        }
+        else if (/\s/.test(ch)) {
+            if (inToken)
+                args.push(cur);
+            cur = '';
+            inToken = false;
+        }
+        else {
+            cur += ch;
+            inToken = true;
+        }
+    }
+    if (quote)
+        throw new Failure('restriction_violation', 'shell command rejected: unterminated quote');
+    if (inToken)
+        args.push(cur);
+    return args;
+}
+const SEARCH_ENDPOINT = 'https://html.duckduckgo.com/html/';
+const MAX_SEARCH_RESULTS = 10;
+const decodeEntities = (s) => s
+    .replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+    .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d)))
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;|&apos;/g, "'")
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&');
+const plainText = (html) => decodeEntities(html.replace(/<[^>]*>/g, '')).replace(/\s+/g, ' ').trim();
+/** Extracts result links from DuckDuckGo's HTML results page; result links are redirects carrying the target in `uddg`. */
+export function parseSearchResults(html) {
+    const results = [];
+    const link = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/g;
+    const snippets = [...html.matchAll(/<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g)];
+    let m;
+    let i = 0;
+    while ((m = link.exec(html)) && results.length < MAX_SEARCH_RESULTS) {
+        const href = decodeEntities(m[1]);
+        let url = href;
+        try {
+            const u = new URL(href, 'https://duckduckgo.com');
+            url = u.searchParams.get('uddg') ?? u.href;
+        }
+        catch {
+            // keep the raw href
+        }
+        results.push({ title: plainText(m[2]), url, snippet: snippets[i] ? plainText(snippets[i][1]) : '' });
+        i++;
+    }
+    return results;
+}
+const looksLikeUrl = (s) => /^[a-z][a-z0-9+.-]*:\/\//i.test(s);
+const looksLikePath = (s) => /[\\/]/.test(s) || s.startsWith('.') || s.startsWith('~') || /^[a-z]:/i.test(s);
+/**
+ * Executes the built-in tools. Every call is checked against the active restrictions,
+ * whether it comes from the script itself or from the LLM.
+ */
+export class ToolHost {
+    restrictions;
+    cwd;
+    constructor(restrictions, cwd) {
+        this.restrictions = restrictions;
+        this.cwd = cwd;
+    }
+    async invoke(name, params) {
+        switch (name) {
+            case 'read_file': return this.readFile(needString(name, params, 'path'));
+            case 'write_file': {
+                const content = params.content;
+                if (typeof content !== 'string')
+                    throw new Failure('tool_error', "write_file: parameter 'content' must be a string");
+                return this.writeFile(needString(name, params, 'path'), content);
+            }
+            case 'web_fetch': return this.webFetch(needString(name, params, 'url'));
+            case 'web_search': return this.webSearch(needString(name, params, 'query'));
+            case 'shell': return this.shell(needString(name, params, 'command'));
+        }
+    }
+    async readFile(p) {
+        const canonical = this.restrictions.checkPath(p, 'read');
+        try {
+            return truncate(await fs.readFile(canonical, 'utf8'));
+        }
+        catch (e) {
+            throw new Failure('tool_error', `read_file '${p}': ${e.message}`);
+        }
+    }
+    async writeFile(p, content) {
+        const canonical = this.restrictions.checkPath(p, 'write');
+        try {
+            await fs.mkdir(path.dirname(canonical), { recursive: true });
+            await fs.writeFile(canonical, content, 'utf8');
+        }
+        catch (e) {
+            throw new Failure('tool_error', `write_file '${p}': ${e.message}`);
+        }
+        return `Wrote ${Buffer.byteLength(content)} bytes to ${canonical}`;
+    }
+    async webFetch(url) {
+        let current = this.restrictions.checkUrl(url);
+        for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+            let res;
+            try {
+                res = await fetch(current, { redirect: 'manual', signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+            }
+            catch (e) {
+                throw new Failure('tool_error', `web_fetch '${current.href}': ${e.message}`);
+            }
+            if (res.status >= 300 && res.status < 400 && res.headers.get('location')) {
+                current = this.restrictions.checkUrl(new URL(res.headers.get('location'), current).href);
+                continue;
+            }
+            const body = truncate(await res.text());
+            if (!res.ok)
+                throw new Failure('tool_error', `web_fetch '${current.href}': HTTP ${res.status}\n${body}`);
+            return body;
+        }
+        throw new Failure('tool_error', `web_fetch '${url}': too many redirects`);
+    }
+    /** Searches DuckDuckGo's HTML endpoint (no API key); it is a network call, so `restrict net` applies to it. */
+    async webSearch(query) {
+        const url = this.restrictions.checkUrl(`${SEARCH_ENDPOINT}?q=${encodeURIComponent(query)}`);
+        let html;
+        try {
+            const res = await fetch(url, {
+                headers: { 'user-agent': 'Mozilla/5.0 (compatible; spl-lang)' },
+                signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            html = await res.text();
+        }
+        catch (e) {
+            throw new Failure('tool_error', `web_search '${query}': ${e.message}`);
+        }
+        const results = parseSearchResults(html);
+        if (results.length === 0)
+            return `No results for "${query}".`;
+        return results.map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}${r.snippet ? `\n   ${r.snippet}` : ''}`).join('\n');
+    }
+    async shell(command) {
+        if (!this.restrictions.active)
+            return this.run(command, { shell: true });
+        // With any restriction active only plain commands are accepted, so the checks below are exact.
+        if (SHELL_META.test(command)) {
+            throw new Failure('restriction_violation', 'shell command rejected: chaining, redirection and substitution are not allowed inside a restrict block');
+        }
+        const argv = splitCommand(command);
+        if (argv.length === 0)
+            throw new Failure('tool_error', 'shell: empty command');
+        this.restrictions.checkExec(argv[0]);
+        for (const arg of argv.slice(1)) {
+            const value = arg.startsWith('-') && arg.includes('=') ? arg.slice(arg.indexOf('=') + 1) : arg;
+            if (looksLikeUrl(value)) {
+                if (this.restrictions.has('net'))
+                    this.restrictions.checkHost(new URL(value).hostname.toLowerCase());
+            }
+            else if (this.restrictions.has('fs') && value && !value.startsWith('-') && looksLikePath(value)) {
+                this.restrictions.checkPath(value, 'read');
+            }
+        }
+        if (argv.some((a) => a.includes('"'))) {
+            throw new Failure('restriction_violation', 'shell command rejected: embedded double quotes are not allowed inside a restrict block');
+        }
+        if (process.platform === 'win32') {
+            // .cmd shims (npm, ...) need a shell on Windows; metacharacters were already rejected.
+            return this.run(argv.map((a) => (/\s/.test(a) || a === '' ? `"${a}"` : a)).join(' '), { shell: true });
+        }
+        return this.run(argv[0], { shell: false, args: argv.slice(1) });
+    }
+    run(command, opts) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, opts.args ?? [], { cwd: this.cwd, shell: opts.shell, windowsHide: true });
+            let out = '';
+            const collect = (d) => {
+                if (out.length < MAX_TEXT * 2)
+                    out += d.toString('utf8');
+            };
+            child.stdout.on('data', collect);
+            child.stderr.on('data', collect);
+            const timer = setTimeout(() => child.kill(), SHELL_TIMEOUT_MS);
+            child.on('error', (e) => {
+                clearTimeout(timer);
+                reject(new Failure('tool_error', `shell: ${e.message}`));
+            });
+            child.on('close', (code, signal) => {
+                clearTimeout(timer);
+                const text = truncate(out);
+                if (code === 0)
+                    resolve(text);
+                else
+                    reject(new Failure('tool_error', `shell: ${signal ? `terminated by ${signal}` : `exit code ${code}`}\n${text}`));
+            });
+        });
+    }
+}

package/dist/values.d.ts

@@ -0,0 +1,49 @@
+import type { Stmt } from './ast.js';
+import { Failure } from './errors.js';
+export type Value = null | boolean | number | string | Value[] | {
+    [key: string]: Value;
+} | FunctionValue;
+export interface Env {
+    vars: Map<string, Value>;
+    parent?: Env;
+}
+export interface UserFunction {
+    __fn: 'user';
+    name: string;
+    params: string[];
+    body: Stmt[];
+    closure: Env;
+}
+export interface BuiltinFunction {
+    __fn: 'builtin';
+    name: string;
+    call: (args: Value[]) => Value;
+}
+export type FunctionValue = UserFunction | BuiltinFunction;
+export declare const runtimeError: (msg: string) => Failure;
+export declare function isFunction(v: unknown): v is FunctionValue;
+export declare function isList(v: unknown): v is Value[];
+export declare function isDict(v: unknown): v is {
+    [key: string]: Value;
+};
+export declare function typeName(v: Value): string;
+export declare function truthy(v: Value): boolean;
+export declare function hasKey(o: {
+    [key: string]: Value;
+}, k: string): boolean;
+/** Assigns a dict key without ever touching the prototype chain. */
+export declare function setKey(o: {
+    [key: string]: Value;
+}, k: string, v: Value): void;
+export declare function newDict(entries?: Iterable<[string, Value]>): {
+    [key: string]: Value;
+};
+/** Display form used for string interpolation and str(). */
+export declare function str(v: Value): string;
+/** Converts to a plain JSON-compatible value (functions become descriptive strings). */
+export declare function toJson(v: Value): unknown;
+/** Converts parsed JSON into a Value (JSON objects are already safe dicts). */
+export declare function fromJson(j: unknown): Value;
+export declare function equals(a: Value, b: Value): boolean;
+/** Ordering for numbers, strings and (lexicographically) lists. */
+export declare function compareValues(a: Value, b: Value): number;