@harmoniclabs/pebble 0.1.0-dev0

package/dist/compiler/internalVar.d.ts

@@ -0,0 +1,19 @@
+/** invalid char for normal js identifiers */
+export declare const PEBBLE_INTERNAL_IDENTIFIER_PREFIX = "\u00A7";
+/** invalid char for normal js identifiers */
+export declare const PEBBLE_INTERNAL_IDENTIFIER_SEPARATOR = "#";
+/**
+ * Creates and tracks unique internal variable names for the Pebble compiler
+ */
+export declare class UidGenerator {
+    constructor();
+    private readonly uids;
+    getUid(): string;
+    /**
+     * Generates a unique internal variable name
+     */
+    getUniqueInternalName(name: string): string;
+}
+export declare const defaultSymbolForge: UidGenerator;
+export declare const getUniqueInternalName: (name: string) => string;
+export declare function isInternalName(name: string): boolean;

package/dist/compiler/internalVar.js

@@ -0,0 +1,56 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { toHex } from "@harmoniclabs/uint8array-utils";
+/** invalid char for normal js identifiers */
+export const PEBBLE_INTERNAL_IDENTIFIER_PREFIX = "§";
+/** invalid char for normal js identifiers */
+export const PEBBLE_INTERNAL_IDENTIFIER_SEPARATOR = "#";
+// Keep getRandomBytes outside the class as requested
+let getRandomBytes = (bytes) => {
+    for (let i = 0; i < bytes.length; i++)
+        bytes[i] = ((Math.random() * 0x100) >>> 0);
+    return bytes;
+};
+try {
+    if (typeof globalThis !== "undefined"
+        && typeof globalThis.crypto !== "undefined"
+        && isObject(globalThis.crypto)
+        && typeof globalThis.crypto.getRandomValues === "function")
+        getRandomBytes = globalThis.crypto.getRandomValues.bind(globalThis.crypto);
+}
+catch { }
+const uidSet = new Set();
+/**
+ * Creates and tracks unique internal variable names for the Pebble compiler
+ */
+export class UidGenerator {
+    constructor() {
+        this.uids = uidSet;
+    }
+    uids;
+    getUid() {
+        const bytes = new Uint8Array(Math.max(1, Math.log1p(this.uids.size) >>> 0));
+        let uid;
+        do {
+            uid = toHex(getRandomBytes(bytes));
+        } while (this.uids.has(uid));
+        this.uids.add(uid);
+        return uid;
+    }
+    /**
+     * Generates a unique internal variable name
+     */
+    getUniqueInternalName(name) {
+        if (typeof name !== "string" || name.length === 0)
+            name = PEBBLE_INTERNAL_IDENTIFIER_PREFIX;
+        name = name.startsWith(PEBBLE_INTERNAL_IDENTIFIER_PREFIX) ? name :
+            PEBBLE_INTERNAL_IDENTIFIER_PREFIX + name;
+        return name + "_" + this.getUid();
+    }
+}
+// Create a default instance for backward compatibility
+export const defaultSymbolForge = new UidGenerator();
+// Export the original functions for backward compatibility
+export const getUniqueInternalName = defaultSymbolForge.getUniqueInternalName.bind(defaultSymbolForge);
+export function isInternalName(name) {
+    return name.startsWith(PEBBLE_INTERNAL_IDENTIFIER_PREFIX);
+}

package/dist/compiler/io/CompilerIoApi.d.ts

@@ -0,0 +1,36 @@
+import { DiagnosticMessage } from "../../diagnostics/DiagnosticMessage.js";
+import { MaybePromise } from "../../utils/MaybePromise.js";
+import { IOutputStream } from "./IOutputStream.js";
+/** Compiler API options. */
+export interface CompilerIoApi {
+    /** Standard output stream to use. */
+    readonly stdout: IOutputStream;
+    /** Standard error stream to use. */
+    readonly stderr: IOutputStream;
+    /** Reads a file from disk (or memory). */
+    readFile: (filename: string, baseDir: string) => MaybePromise<string | undefined>;
+    /** Writes a file to disk (or memory). */
+    writeFile: (filename: string, contents: Uint8Array | string, baseDir: string) => MaybePromise<void>;
+    /** Lists all files within a directory. */
+    exsistSync: (filename: string) => boolean;
+    /** Lists all files within a directory. */
+    listFiles: (dirname: string, baseDir: string) => MaybePromise<string[] | undefined>;
+    /** Handler for diagnostic messages. */
+    reportDiagnostic: (diagnostic: DiagnosticMessage) => void;
+}
+type MemoryFs = Map<string, Uint8Array>;
+export interface MemoryCompilerIoApi extends CompilerIoApi {
+    /** Memory file system for reading files. */
+    sources: MemoryFs;
+    /** Memory file system for writing files. */
+    outputs: MemoryFs;
+    /**
+     * if true, `console.log` is used as `stdout` and `console.error` as `stderr`
+     * otherwise both will be their own `MemoryStream`.
+     *
+     * @default false
+    */
+    useConsoleAsOutput?: boolean;
+}
+export declare function createMemoryCompilerIoApi({ sources, outputs, useConsoleAsOutput }?: Partial<MemoryCompilerIoApi>): MemoryCompilerIoApi;
+export {};

package/dist/compiler/io/CompilerIoApi.js

@@ -0,0 +1,62 @@
+import { fromUtf8, toUtf8 } from "@harmoniclabs/uint8array-utils";
+import { ConsoleErrorStream, ConsoleLogStream, MemoryStream } from "./IOutputStream.js";
+import { getAbsolutePath } from "../path/getAbsolutePath.js";
+export function createMemoryCompilerIoApi({ sources, outputs, useConsoleAsOutput } = {}) {
+    if (typeof useConsoleAsOutput !== "boolean")
+        useConsoleAsOutput = false;
+    if (!(sources instanceof Map))
+        sources = new Map();
+    if (!(outputs instanceof Map))
+        outputs = new Map();
+    const stderr = useConsoleAsOutput ? new ConsoleErrorStream() : new MemoryStream();
+    return {
+        stdout: useConsoleAsOutput ? new ConsoleLogStream() : new MemoryStream(),
+        stderr,
+        readFile: memoryFsRead.bind(sources),
+        writeFile: memoryFsWrite.bind(outputs),
+        exsistSync: exsistSync.bind(sources),
+        listFiles: memoryFsList.bind(sources),
+        reportDiagnostic: defaultReportDiagnostic.bind(stderr),
+        sources,
+        outputs
+    };
+}
+function defaultReportDiagnostic(diagnostic) {
+    this.write(diagnostic.toString() + "\n");
+}
+function memoryFsAdaptFilename(filename) {
+    filename = getAbsolutePath(filename, "/");
+    if (typeof filename !== "string")
+        return "";
+    // filename = filename.replace( /\\/g, "/" );
+    filename = filename.startsWith("/") ? filename.slice(1) : filename;
+    return filename;
+}
+function memoryFsRead(filename) {
+    filename = memoryFsAdaptFilename(filename);
+    while (filename.startsWith("/"))
+        filename = filename.slice(1);
+    const result = this.get(filename);
+    return result instanceof Uint8Array ? toUtf8(result) : undefined;
+}
+function memoryFsList() {
+    return Array.from(this.keys());
+}
+function memoryFsWrite(filename, contents) {
+    filename = memoryFsAdaptFilename(filename);
+    if (!(contents instanceof Uint8Array)) {
+        if (typeof contents === "string") {
+            contents = fromUtf8(contents);
+        }
+        else if (typeof contents.toString === "function") {
+            contents = fromUtf8(contents.toString());
+        }
+        else {
+            throw new Error("cannot write contents: invalid type");
+        }
+    }
+    this.set(filename, contents);
+}
+function exsistSync(filename) {
+    return this.has(filename);
+}

package/dist/compiler/io/IOutputStream.d.ts

@@ -0,0 +1,28 @@
+/** A compatible output stream. */
+export interface IOutputStream {
+    /** Writes a chunk of data to the stream. */
+    write(chunk: Uint8Array | string): void;
+}
+export declare class ConsoleLogStream implements IOutputStream {
+    write(chunk: Uint8Array | string): void;
+}
+export declare class ConsoleErrorStream implements IOutputStream {
+    write(chunk: Uint8Array | string): void;
+}
+/** An in-memory output stream. */
+export interface IMemoryStream extends IOutputStream {
+    /** Resets the stream to offset zero. */
+    reset(): void;
+    /** Converts the output to a buffer. */
+    toBuffer(): Uint8Array;
+    /** Converts the output to a string. */
+    toString(): string;
+}
+export declare class MemoryStream implements IMemoryStream {
+    private chunks;
+    constructor();
+    write(chunk: Uint8Array | string): void;
+    reset(): void;
+    toBuffer(): Uint8Array;
+    toString(): string;
+}

package/dist/compiler/io/IOutputStream.js

@@ -0,0 +1,45 @@
+import { fromUtf8, concatUint8Array, toUtf8 } from "@harmoniclabs/uint8array-utils";
+export class ConsoleLogStream {
+    write(chunk) {
+        if (chunk instanceof Uint8Array) {
+            console.log(toUtf8(chunk));
+        }
+        else {
+            console.log(chunk.toString());
+        }
+    }
+}
+export class ConsoleErrorStream {
+    write(chunk) {
+        if (chunk instanceof Uint8Array) {
+            console.error(toUtf8(chunk));
+        }
+        else {
+            console.error(chunk.toString());
+        }
+    }
+}
+export class MemoryStream {
+    chunks;
+    constructor() {
+        this.chunks = [];
+    }
+    write(chunk) {
+        if (typeof chunk === "string") {
+            this.chunks.push(fromUtf8(chunk));
+        }
+        else {
+            this.chunks.push(chunk);
+        }
+    }
+    reset() {
+        this.chunks.length = 0;
+    }
+    toBuffer() {
+        return concatUint8Array(...this.chunks);
+        // return new Uint8Array(this.toString().length);
+    }
+    toString() {
+        return this.chunks.map(chunk => toUtf8(chunk)).join("");
+    }
+}

package/dist/compiler/io/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./CompilerIoApi.js";
+export * from "./IOutputStream.js";

package/dist/compiler/io/index.js

@@ -0,0 +1,2 @@
+export * from "./CompilerIoApi.js";
+export * from "./IOutputStream.js";

package/dist/compiler/path/getAbsolutePath.d.ts

@@ -0,0 +1,12 @@
+export declare function getEnvRelativePath(filePath: string, projectRoot: string): string | undefined;
+/**
+ * Takes a relative path and an absolute path, and returns the absolute path
+ * corresponding to the relative path starting from the absolute path.
+ * Returns undefined if the relative path goes beyond the root directory.
+ *
+ * @example
+ * getAbsolutePath("./c","/a/b.pebble") // returns "/a/c.pebble"
+ * getAbsolutePath("../c","/a/b.pebble") // returns "/c.pebble"
+ * getAbsolutePath("../../c", "/a/b.pebble") // returns undefined
+ */
+export declare function getAbsolutePath(relativePath: string, absolutePath: string): string | undefined;

package/dist/compiler/path/getAbsolutePath.js

@@ -0,0 +1,114 @@
+import { extension, PATH_DELIMITER } from "../../common.js";
+/**
+ * Gets the directory part of a path
+ */
+function getDirectoryPath(path) {
+    const lastSlashIndex = path.lastIndexOf(PATH_DELIMITER);
+    return lastSlashIndex >= 0 ? path.slice(0, lastSlashIndex + 1) : PATH_DELIMITER;
+}
+/**
+ * Splits a path into segments
+ */
+function splitPath(path) {
+    return path.split(PATH_DELIMITER).filter(segment => segment !== '');
+}
+/**
+ * Joins path segments into a normalized path
+ */
+function joinPath(segments) {
+    return segments.length > 0 ? PATH_DELIMITER + segments.join(PATH_DELIMITER) : PATH_DELIMITER;
+}
+function getPathExtension(path) {
+    const lastDotIndex = path.lastIndexOf('.');
+    if (lastDotIndex === -1) {
+        return undefined; // No extension found
+    }
+    const extension = path.slice(lastDotIndex).trimEnd();
+    if (extension.includes(PATH_DELIMITER)) {
+        return undefined; // Dot in the name of a directory
+    }
+    if (extension.length === 0 || extension === ".")
+        return undefined;
+    return extension;
+}
+/**
+ * Adds extension if needed
+ */
+function addExtension(path, endsWithSlash) {
+    path = path.trim();
+    // If path already has an extension, return it as is
+    if (typeof getPathExtension(path) === "string")
+        return path;
+    // If the path ends with a slash or the original relative path ended with a slash,
+    // append 'index' + extension
+    if (path.endsWith(PATH_DELIMITER) || endsWithSlash) {
+        // Ensure path ends with a slash
+        if (!path.endsWith(PATH_DELIMITER)) {
+            path += PATH_DELIMITER;
+        }
+        return path + 'index' + extension;
+    }
+    // Otherwise just add the extension
+    return path + extension;
+}
+export function getEnvRelativePath(filePath, projectRoot) {
+    if (!(typeof filePath === 'string' &&
+        typeof projectRoot === 'string'))
+        return undefined;
+    projectRoot = projectRoot.trim();
+    filePath = getAbsolutePath(filePath.trim(), projectRoot);
+    if (!filePath)
+        return undefined;
+    if (!projectRoot.endsWith(PATH_DELIMITER))
+        projectRoot = projectRoot + PATH_DELIMITER;
+    while (filePath.startsWith(PATH_DELIMITER))
+        filePath = filePath.slice(PATH_DELIMITER.length);
+    return projectRoot + filePath;
+}
+/**
+ * Takes a relative path and an absolute path, and returns the absolute path
+ * corresponding to the relative path starting from the absolute path.
+ * Returns undefined if the relative path goes beyond the root directory.
+ *
+ * @example
+ * getAbsolutePath("./c","/a/b.pebble") // returns "/a/c.pebble"
+ * getAbsolutePath("../c","/a/b.pebble") // returns "/c.pebble"
+ * getAbsolutePath("../../c", "/a/b.pebble") // returns undefined
+ */
+export function getAbsolutePath(relativePath, absolutePath) {
+    if (!absolutePath || typeof absolutePath !== 'string') {
+        return undefined;
+    }
+    // Check if the relative path ends with a directory separator
+    const endsWithSlash = relativePath.endsWith(PATH_DELIMITER) || relativePath.endsWith('./');
+    // Get the directory containing the absolute path
+    const baseDir = getDirectoryPath(absolutePath);
+    // Split paths into segments
+    const baseSegments = splitPath(baseDir);
+    const relativeSegments = splitPath(relativePath);
+    // Process relative path segments
+    const resultSegments = [...baseSegments];
+    for (const segment of relativeSegments) {
+        if (segment === '.') {
+            // Current directory - do nothing
+            continue;
+        }
+        else if (segment === '..') {
+            // Go up one directory
+            if (resultSegments.length === 0) {
+                // Attempting to go beyond root directory
+                return undefined;
+            }
+            resultSegments.pop();
+        }
+        else {
+            // Regular directory or file
+            resultSegments.push(segment);
+        }
+    }
+    // Join segments to form the result path
+    let result = joinPath(resultSegments);
+    // Add extension from the original file if needed
+    result = addExtension(result, endsWithSlash);
+    return result;
+}

package/dist/compiler/path/path.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Various file path utility.
+ * @license Apache-2.0
+ */
+export {};

package/dist/compiler/path/path.js

@@ -0,0 +1,160 @@
+/**
+ * @fileoverview Various file path utility.
+ * @license Apache-2.0
+ */
+import { extension, PATH_DELIMITER } from "../../common.js";
+const separator = 47 /* CharCode.Slash */;
+function getAbsolutePath(path, requestingPath) {
+    if (typeof requestingPath !== "string" || requestingPath === "")
+        return undefined;
+    const internalPath = getInternalPath(path);
+    const resolved = resolveProjAbsolutePath(internalPath, requestingPath);
+    if (typeof resolved !== "string")
+        return undefined;
+    return adjustPathEnd(resolved);
+}
+function getInternalPath(path) {
+    return removeSingleDotDirsFromPath(path).trim();
+}
+function adjustPathEnd(path) {
+    if (path.endsWith("/"))
+        return path + "index" + extension;
+    if (!path.endsWith(extension))
+        path = path + extension;
+    return path;
+}
+/** Resolves the specified path relative to the specified origin. */
+function resolveProjAbsolutePath(toResolve, fromPath) {
+    const fromDirname = dirname(fromPath);
+    toResolve = removeSingleDotDirsFromPath(toResolve);
+    const fromDirs = fromDirname.split(PATH_DELIMITER).filter(d => d !== "");
+    const toDirs = toResolve.split(PATH_DELIMITER).filter(d => d !== "");
+    for (let i = 0; i < toDirs.length; i++) {
+        const dir = toDirs[i];
+        if (dir === "..") {
+            fromDirs.pop();
+            if (fromDirs.length === 0) {
+                if (toDirs.length === 0)
+                    return undefined;
+                if (toDirs[0] === "..")
+                    return undefined; // out of project root
+            }
+            toDirs.splice(i--, 1);
+        }
+        else if (dir !== ".") {
+            fromDirs.push(dir);
+        }
+    }
+    let result = removeSingleDotDirsFromPath(fromDirs.join(PATH_DELIMITER));
+    // result = result === "." || result.endsWith( fromDirname.slice( 0, fromDirname.length - 1 ) ) ?
+    //     result + PATH_DELIMITER :
+    //     result;
+    // result = result.startsWith("/") ? result : "/" + result;
+    result = result.replace("//", "/");
+    if (result.startsWith("./"))
+        return result.slice(1);
+    if (!result.startsWith("/"))
+        return "/" + result;
+    return result;
+}
+/** Obtains the directory portion of a normalized path. */
+function dirname(path) {
+    const wasEndingWithSlash = path.endsWith(PATH_DELIMITER);
+    path = removeSingleDotDirsFromPath(path);
+    if (!path.endsWith(PATH_DELIMITER) && wasEndingWithSlash)
+        path += PATH_DELIMITER;
+    let pos = path.length;
+    if (pos <= 1) {
+        if (pos === 0)
+            return ".";
+        if (path.charCodeAt(0) === separator) {
+            path = path.endsWith(PATH_DELIMITER) ? path : path + PATH_DELIMITER;
+            return path;
+        }
+    }
+    while (--pos > 0) {
+        if (path.charCodeAt(pos) === separator) {
+            path = path.substring(0, pos);
+            return path.endsWith(PATH_DELIMITER) ? path : path + PATH_DELIMITER;
+        }
+    }
+    return "./";
+}
+/**
+ * Normalizes the specified path, removing interior placeholders.
+ * Expects a posix-compatible relative path (not Windows compatible).
+ */
+function removeSingleDotDirsFromPath(path) {
+    let pos = 0;
+    let len = path.length;
+    // trim leading './'
+    while (pos + 1 < len &&
+        path.charCodeAt(pos) === 46 /* CharCode.Dot */ &&
+        path.charCodeAt(pos + 1) === separator) {
+        pos += 2;
+    }
+    if (pos > 0 || len < path.length) {
+        path = path.substring(pos, len);
+        len -= pos;
+        pos = 0;
+    }
+    let atEnd;
+    while (pos + 1 < len) {
+        atEnd = false;
+        // we are only interested in '/.' sequences ...
+        if (!(path.charCodeAt(pos) === separator &&
+            path.charCodeAt(pos + 1) === 46 /* CharCode.Dot */)) {
+            ++pos;
+            continue;
+        }
+        // '/.' ( '/' | $ )
+        atEnd = pos + 2 === len;
+        if (atEnd ||
+            pos + 2 < len &&
+                path.charCodeAt(pos + 2) === separator) {
+            path = atEnd
+                ? path.substring(0, pos)
+                : path.substring(0, pos) + path.substring(pos + 2);
+            len -= 2;
+            continue;
+        }
+        // '/.' ( './' | '.' $ )
+        atEnd = pos + 3 === len;
+        if (!(atEnd && path.charCodeAt(pos + 2) === 46 /* CharCode.Dot */ ||
+            pos + 3 < len &&
+                path.charCodeAt(pos + 2) === 46 /* CharCode.Dot */ &&
+                path.charCodeAt(pos + 3) === separator)) {
+            ++pos;
+            continue;
+        }
+        // find preceeding '/'
+        let ipos = pos;
+        while (--ipos >= 0) {
+            if (path.charCodeAt(ipos) !== separator)
+                continue;
+            if (pos - ipos !== 3 ||
+                path.charCodeAt(ipos + 1) !== 46 /* CharCode.Dot */ ||
+                path.charCodeAt(ipos + 2) !== 46 /* CharCode.Dot */) { // exclude '..' itself
+                path = atEnd
+                    ? path.substring(0, ipos)
+                    : path.substring(0, ipos) + path.substring(pos + 3);
+                len -= pos + 3 - ipos;
+                pos = ipos - 1; // incremented again at end of loop
+            }
+            break;
+        }
+        // if there's no preceeding '/', trim start if non-empty
+        if (ipos < 0 && pos > 0) {
+            if (pos !== 2 ||
+                path.charCodeAt(0) !== 46 /* CharCode.Dot */ ||
+                path.charCodeAt(1) !== 46 /* CharCode.Dot */) { // exclude '..' itself
+                path = path.substring(pos + 4);
+                len = path.length;
+                continue;
+            }
+        }
+        pos++;
+    }
+    // path = path.endsWith( PATH_DELIMITER ) ? path.substring(0, len - 1) : path;
+    return len > 0 ? path : ".";
+}

package/dist/compiler/tir/expressions/ITirExpr.d.ts

@@ -0,0 +1,11 @@
+import type { HasSourceRange } from "../../../ast/nodes/HasSourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import type { TirType } from "../types/TirType.js";
+import type { ToIRTermCtx } from "./ToIRTermCtx.js";
+export interface ITirExpr extends HasSourceRange {
+    readonly type: TirType;
+    readonly isConstant: boolean;
+    deps: () => string[];
+    toIR: (ctx: ToIRTermCtx) => IRTerm;
+    clone: () => ITirExpr;
+}

package/dist/compiler/tir/expressions/ITirExpr.js

@@ -0,0 +1 @@
+export {};

package/dist/compiler/tir/expressions/TirAssertAndContinueExpr.d.ts

@@ -0,0 +1,19 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { IRTerm } from "../../../IR/IRTerm.js";
+import { TirAssertStmt } from "../statements/TirAssertStmt.js";
+import { TirType } from "../types/TirType.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+export declare class TirAssertAndContinueExpr implements ITirExpr {
+    conditions: TirExpr[];
+    continuation: TirExpr;
+    readonly range: SourceRange;
+    get type(): TirType;
+    constructor(conditions: TirExpr[], continuation: TirExpr, range: SourceRange);
+    clone(): TirAssertAndContinueExpr;
+    static fromStmtsAndContinuation(assertions: TirAssertStmt[], continuation: TirExpr): TirExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}

package/dist/compiler/tir/expressions/TirAssertAndContinueExpr.js

@@ -0,0 +1,41 @@
+import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
+import { IRError } from "../../../IR/IRNodes/IRError.js";
+import { IRForced } from "../../../IR/IRNodes/IRForced.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
+import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
+export class TirAssertAndContinueExpr {
+    conditions;
+    continuation;
+    range;
+    get type() {
+        return this.continuation.type;
+    }
+    constructor(conditions, continuation, range) {
+        this.conditions = conditions;
+        this.continuation = continuation;
+        this.range = range;
+    }
+    /// @ts-ignore Return type annotation circularly references itself.
+    clone() {
+        return new TirAssertAndContinueExpr(this.conditions.map(c => c.clone()), this.continuation.clone(), this.range.clone());
+    }
+    static fromStmtsAndContinuation(assertions, continuation) {
+        if (assertions.length <= 0)
+            return continuation;
+        return new TirAssertAndContinueExpr(assertions.map(a => a.toSafeCondition()), continuation, continuation.range);
+    }
+    deps() {
+        return (this.conditions
+            .reduce((accum, cond) => mergeSortedStrArrInplace(accum, cond.deps()), this.continuation.deps()));
+    }
+    get isConstant() { return this.continuation.isConstant; }
+    toIR(ctx) {
+        const irContinuation = this.continuation.toIR(ctx);
+        if (this.conditions.length <= 0)
+            return irContinuation;
+        let irConditions = this.conditions.pop().toIR(ctx);
+        irConditions = this.conditions.reduce((ir, cond) => _ir_apps(IRNative._strictAnd, ir, cond.toIR(ctx)), irConditions);
+        return new IRForced(_ir_apps(IRNative.strictIfThenElse, irConditions, new IRDelayed(irContinuation), new IRDelayed(new IRError())));
+    }
+}

package/dist/compiler/tir/expressions/TirCallExpr.d.ts

@@ -0,0 +1,17 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
+import { TirType } from "../types/TirType.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+export declare class TirCallExpr implements ITirExpr {
+    func: TirExpr;
+    readonly args: TirExpr[];
+    readonly type: TirType;
+    readonly range: SourceRange;
+    constructor(func: TirExpr, args: TirExpr[], type: TirType, range: SourceRange);
+    clone(): TirCallExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}