@elaraai/east 0.0.1-beta.0

package/dist/src/expr/integer.js

@@ -0,0 +1,311 @@
+import { get_location } from "../location.js";
+import { FloatType, IntegerType, isTypeEqual } from "../types.js";
+import { AstSymbol, Expr, FactorySymbol } from "./expr.js";
+import { valueOrExprToAst } from "./ast.js";
+/**
+ * Expression representing integer values and operations.
+ *
+ * IntegerExpr provides arithmetic, comparison, and conversion operations for 64-bit signed integers.
+ * Operations automatically promote to FloatExpr when mixed with float operands.
+ *
+ * @example
+ * ```ts
+ * // Basic arithmetic
+ * const calculate = East.function([IntegerType, IntegerType], IntegerType, ($, a, b) => {
+ *   const sum = a.add(b);
+ *   const product = a.multiply(b);
+ *   const power = a.pow(2n);
+ *   $.return(sum.add(product).add(power));
+ * });
+ *
+ * // Integer division and remainder
+ * const divMod = East.function([IntegerType, IntegerType], StructType({quot: IntegerType, rem: IntegerType}), ($, x, y) => {
+ *   $.return({quot: x.divide(y), rem: x.remainder(y)});
+ * });
+ *
+ * // Type promotion with floats
+ * const mixed = East.function([IntegerType], FloatType, ($, x) => {
+ *   $.return(x.add(2.5));  // Returns FloatExpr
+ * });
+ * ```
+ */
+export class IntegerExpr extends Expr {
+    constructor(ast, createExpr) {
+        super(IntegerType, ast, createExpr);
+    }
+    /**
+     * Negates an integer value (-x).
+     *
+     * @returns The negated integer
+     *
+     * @example
+     * ```ts
+     * const negate = East.function([IntegerType], IntegerType, ($, x) => {
+     *   $.return(x.negate());
+     * });
+     * const compiled = East.compile(negate.toIR(), []);
+     * compiled(5n);   // -5n
+     * compiled(-3n);  // 3n
+     * ```
+     */
+    negate() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            location: get_location(2),
+            builtin: "IntegerNegate",
+            type_parameters: [],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    add(y) {
+        const rightAst = valueOrExprToAst(y);
+        if (isTypeEqual(rightAst.type, FloatType)) {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: FloatType,
+                location: get_location(2),
+                builtin: "FloatAdd",
+                type_parameters: [],
+                arguments: [this.toFloat()[AstSymbol], rightAst],
+            });
+        }
+        else {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: IntegerType,
+                location: get_location(2),
+                builtin: "IntegerAdd",
+                type_parameters: [],
+                arguments: [this[AstSymbol], rightAst],
+            });
+        }
+    }
+    subtract(y) {
+        const rightAst = valueOrExprToAst(y);
+        if (isTypeEqual(rightAst.type, FloatType)) {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: FloatType,
+                location: get_location(2),
+                builtin: "FloatSubtract",
+                type_parameters: [],
+                arguments: [this.toFloat()[AstSymbol], rightAst],
+            });
+        }
+        else {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: IntegerType,
+                location: get_location(2),
+                builtin: "IntegerSubtract",
+                type_parameters: [],
+                arguments: [this[AstSymbol], rightAst],
+            });
+        }
+    }
+    multiply(y) {
+        const rightAst = valueOrExprToAst(y);
+        if (isTypeEqual(rightAst.type, FloatType)) {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: FloatType,
+                location: get_location(2),
+                builtin: "FloatMultiply",
+                type_parameters: [],
+                arguments: [this.toFloat()[AstSymbol], rightAst],
+            });
+        }
+        else {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: IntegerType,
+                location: get_location(2),
+                builtin: "IntegerMultiply",
+                type_parameters: [],
+                arguments: [this[AstSymbol], rightAst],
+            });
+        }
+    }
+    divide(y) {
+        const rightAst = valueOrExprToAst(y);
+        if (isTypeEqual(rightAst.type, FloatType)) {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: FloatType,
+                location: get_location(2),
+                builtin: "FloatDivide",
+                type_parameters: [],
+                arguments: [this.toFloat()[AstSymbol], rightAst],
+            });
+        }
+        else {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: IntegerType,
+                location: get_location(2),
+                builtin: "IntegerDivide",
+                type_parameters: [],
+                arguments: [this[AstSymbol], rightAst],
+            });
+        }
+    }
+    remainder(y) {
+        const rightAst = valueOrExprToAst(y);
+        if (isTypeEqual(rightAst.type, FloatType)) {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: FloatType,
+                location: get_location(2),
+                builtin: "FloatRemainder",
+                type_parameters: [],
+                arguments: [this.toFloat()[AstSymbol], rightAst],
+            });
+        }
+        else {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: IntegerType,
+                location: get_location(2),
+                builtin: "IntegerRemainder",
+                type_parameters: [],
+                arguments: [this[AstSymbol], rightAst],
+            });
+        }
+    }
+    pow(y) {
+        const rightAst = valueOrExprToAst(y);
+        if (isTypeEqual(rightAst.type, FloatType)) {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: FloatType,
+                location: get_location(2),
+                builtin: "FloatPow",
+                type_parameters: [],
+                arguments: [this.toFloat()[AstSymbol], rightAst],
+            });
+        }
+        else {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: IntegerType,
+                location: get_location(2),
+                builtin: "IntegerPow",
+                type_parameters: [],
+                arguments: [this[AstSymbol], rightAst],
+            });
+        }
+    }
+    /**
+     * Returns the absolute value of an integer.
+     *
+     * @returns The absolute value (always non-negative)
+     *
+     * @example
+     * ```ts
+     * const absoluteValue = East.function([IntegerType], IntegerType, ($, x) => {
+     *   $.return(x.abs());
+     * });
+     * const compiled = East.compile(absoluteValue.toIR(), []);
+     * compiled(5n);    // 5n
+     * compiled(-5n);   // 5n
+     * compiled(0n);    // 0n
+     * ```
+     */
+    abs() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            location: get_location(2),
+            builtin: "IntegerAbs",
+            type_parameters: [],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Returns the sign of an integer (-1 for negative, 0 for zero, 1 for positive).
+     *
+     * @returns -1n, 0n, or 1n depending on the sign of the integer
+     *
+     * @example
+     * ```ts
+     * const getSign = East.function([IntegerType], IntegerType, ($, x) => {
+     *   $.return(x.sign());
+     * });
+     * const compiled = East.compile(getSign.toIR(), []);
+     * compiled(42n);   // 1n
+     * compiled(-17n);  // -1n
+     * compiled(0n);    // 0n
+     * ```
+     */
+    sign() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            location: get_location(2),
+            builtin: "IntegerSign",
+            type_parameters: [],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Computes the integer logarithm with a specified base (floor of log).
+     *
+     * @param base - The base for the logarithm
+     * @returns The floor of log_base(x)
+     *
+     * @remarks Returns 0 if x <= 0 or base <= 1.
+     *
+     * @example
+     * ```ts
+     * const logarithm = East.function([IntegerType, IntegerType], IntegerType, ($, x, base) => {
+     *   $.return(x.log(base));
+     * });
+     * const compiled = East.compile(logarithm.toIR(), []);
+     * compiled(1000n, 10n);  // 3n (10^3 = 1000)
+     * compiled(8n, 2n);      // 3n (2^3 = 8)
+     * compiled(100n, 10n);   // 2n (10^2 = 100)
+     * compiled(7n, 2n);      // 2n (floor of log_2(7) ≈ 2.8)
+     * ```
+     */
+    log(base) {
+        const baseAst = valueOrExprToAst(base);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            location: get_location(2),
+            builtin: "IntegerLog",
+            type_parameters: [],
+            arguments: [this[AstSymbol], baseAst],
+        });
+    }
+    /**
+     * Converts an integer to a floating-point number.
+     *
+     * @returns The integer as a FloatExpr
+     *
+     * @remarks May lose precision for very large integers (beyond 2^53).
+     *
+     * @example
+     * ```ts
+     * const convertToFloat = East.function([IntegerType], FloatType, ($, x) => {
+     *   $.return(x.toFloat());
+     * });
+     * const compiled = East.compile(convertToFloat.toIR(), []);
+     * compiled(42n);    // 42.0
+     * compiled(-17n);   // -17.0
+     * compiled(0n);     // 0.0
+     * ```
+     */
+    toFloat() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: FloatType,
+            location: get_location(2),
+            builtin: "IntegerToFloat",
+            type_parameters: [],
+            arguments: [this[AstSymbol]],
+        });
+    }
+}
+//# sourceMappingURL=integer.js.map

package/dist/src/expr/integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../../src/expr/integer.ts"],"names":[],"mappings":"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"}

package/dist/src/expr/libs/array.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { ArrayType, FloatType, FunctionType, IntegerType } from "../../types.js";
+import { Expr } from "../expr.js";
+import type { ExprType, SubtypeExprOrValue } from "../types.js";
+/** Standard library functions for arrays */
+declare const _default: {
+    /**
+     * Creates an array containing a linear range of integers.
+     *
+     * @param start - The starting value (inclusive)
+     * @param end - The ending value (exclusive)
+     * @param step - The step size between consecutive values (default: 1)
+     * @returns An array expression containing the integer range
+     *
+     * @remarks
+     * The end of the range is exclusive, such that `East.range(0n, n)` produces `[0, 1, 2, ..., n-1]`.
+     * This corresponds with the indices of an array of size `n`.
+     *
+     * @example
+     * ```ts
+     * const makeRange = East.function([], ArrayType(IntegerType), ($) => {
+     *   $.return(East.Array.range(0n, 5n));
+     * });
+     * const compiled = East.compile(makeRange.toIR(), []);
+     * compiled();  // [0n, 1n, 2n, 3n, 4n]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // With step
+     * const makeRangeStep = East.function([], ArrayType(IntegerType), ($) => {
+     *   $.return(East.Array.range(1n, 10n, 2n));
+     * });
+     * const compiled = East.compile(makeRangeStep.toIR(), []);
+     * compiled();  // [1n, 3n, 5n, 7n, 9n]
+     * ```
+     */
+    range(start: Expr<IntegerType> | bigint, end: Expr<IntegerType> | bigint, step?: Expr<IntegerType> | bigint): ExprType<ArrayType<IntegerType>>;
+    /**
+     * Creates an array containing equally-spaced floating point values.
+     *
+     * @param start - The starting value (inclusive)
+     * @param stop - The ending value (inclusive)
+     * @param size - The number of values to generate
+     * @returns An array expression containing the equally-spaced float values
+     *
+     * @remarks
+     * The stop value is inclusive, such that `East.linspace(0.0, 1.0, 11n)` produces 11 values
+     * from `0.0` to `1.0` with a step of `0.1`.
+     *
+     * @example
+     * ```ts
+     * const makeLinspace = East.function([], ArrayType(FloatType), ($) => {
+     *   $.return(East.Array.linspace(0.0, 1.0, 11n));
+     * });
+     * const compiled = East.compile(makeLinspace.toIR(), []);
+     * compiled();  // [0.0, 0.1, 0.2, ..., 0.9, 1.0]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Different spacing
+     * const makeLinspace2 = East.function([], ArrayType(FloatType), ($) => {
+     *   $.return(East.Array.linspace(0.0, 10.0, 5n));
+     * });
+     * const compiled = East.compile(makeLinspace2.toIR(), []);
+     * compiled();  // [0.0, 2.5, 5.0, 7.5, 10.0]
+     * ```
+     */
+    linspace(start: Expr<FloatType> | number, stop: Expr<FloatType> | number, size: Expr<IntegerType> | bigint): ExprType<ArrayType<FloatType>>;
+    /**
+     * Generates an array of a given size programmatically with a function from index to value.
+     *
+     * @typeParam T - The type of elements in the generated array
+     * @param size - The size of the array to generate
+     * @param valueType - The East type of the array elements
+     * @param valueFn - A function that takes an index and returns the value at that index
+     * @returns An array expression containing the programmatically generated values
+     *
+     * @example
+     * ```ts
+     * // Generate array [0, 1, 4, 9, 16] (squares)
+     * const makeSquares = East.function([], ArrayType(IntegerType), ($) => {
+     *   $.return(East.Array.generate(5n, IntegerType, ($, i) => i.multiply(i)));
+     * });
+     * const compiled = East.compile(makeSquares.toIR(), []);
+     * compiled();  // [0n, 1n, 4n, 9n, 16n]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Generate array of strings ["Item 0", "Item 1", "Item 2"]
+     * const makeItems = East.function([], ArrayType(StringType), ($) => {
+     *   $.return(East.Array.generate(3n, StringType, ($, i) => Expr.str`Item ${i}`));
+     * });
+     * const compiled = East.compile(makeItems.toIR(), []);
+     * compiled();  // ["Item 0", "Item 1", "Item 2"]
+     * ```
+     */
+    generate<T>(size: Expr<IntegerType> | bigint, valueType: T, valueFn: SubtypeExprOrValue<FunctionType<[IntegerType], NoInfer<T>>>): ExprType<ArrayType<T>>;
+};
+export default _default;
+//# sourceMappingURL=array.d.ts.map

package/dist/src/expr/libs/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../../src/expr/libs/array.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAiB,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAa,IAAI,EAAc,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEhE,4CAA4C;;IAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;iBACU,IAAI,CAAC,WAAW,CAAC,GAAG,MAAM,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,MAAM,SAAQ,IAAI,CAAC,WAAW,CAAC,GAAG,MAAM,GAAQ,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;IAclJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;oBACa,IAAI,CAAC,SAAS,CAAC,GAAG,MAAM,QAAQ,IAAI,CAAC,SAAS,CAAC,GAAG,MAAM,QAAQ,IAAI,CAAC,WAAW,CAAC,GAAG,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IAc3I;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;aACM,CAAC,QAAQ,IAAI,CAAC,WAAW,CAAC,GAAG,MAAM,aAAa,CAAC,WAAW,kBAAkB,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;;AAxH3J,wBAqIC"}

package/dist/src/expr/libs/array.js

@@ -0,0 +1,140 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { ArrayType, FloatType, FunctionType, IntegerType } from "../../types.js";
+import { AstSymbol, Expr, TypeSymbol } from "../expr.js";
+/** Standard library functions for arrays */
+export default {
+    /**
+     * Creates an array containing a linear range of integers.
+     *
+     * @param start - The starting value (inclusive)
+     * @param end - The ending value (exclusive)
+     * @param step - The step size between consecutive values (default: 1)
+     * @returns An array expression containing the integer range
+     *
+     * @remarks
+     * The end of the range is exclusive, such that `East.range(0n, n)` produces `[0, 1, 2, ..., n-1]`.
+     * This corresponds with the indices of an array of size `n`.
+     *
+     * @example
+     * ```ts
+     * const makeRange = East.function([], ArrayType(IntegerType), ($) => {
+     *   $.return(East.Array.range(0n, 5n));
+     * });
+     * const compiled = East.compile(makeRange.toIR(), []);
+     * compiled();  // [0n, 1n, 2n, 3n, 4n]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // With step
+     * const makeRangeStep = East.function([], ArrayType(IntegerType), ($) => {
+     *   $.return(East.Array.range(1n, 10n, 2n));
+     * });
+     * const compiled = East.compile(makeRangeStep.toIR(), []);
+     * compiled();  // [1n, 3n, 5n, 7n, 9n]
+     * ```
+     */
+    range(start, end, step = 1n) {
+        const start_val = Expr.from(start, IntegerType);
+        const end_val = Expr.from(end, IntegerType);
+        const step_val = Expr.from(step, IntegerType);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: ArrayType(IntegerType),
+            builtin: "ArrayRange",
+            type_parameters: [],
+            arguments: [start_val[AstSymbol], end_val[AstSymbol], step_val[AstSymbol]],
+            location: start_val[AstSymbol].location,
+        });
+    },
+    /**
+     * Creates an array containing equally-spaced floating point values.
+     *
+     * @param start - The starting value (inclusive)
+     * @param stop - The ending value (inclusive)
+     * @param size - The number of values to generate
+     * @returns An array expression containing the equally-spaced float values
+     *
+     * @remarks
+     * The stop value is inclusive, such that `East.linspace(0.0, 1.0, 11n)` produces 11 values
+     * from `0.0` to `1.0` with a step of `0.1`.
+     *
+     * @example
+     * ```ts
+     * const makeLinspace = East.function([], ArrayType(FloatType), ($) => {
+     *   $.return(East.Array.linspace(0.0, 1.0, 11n));
+     * });
+     * const compiled = East.compile(makeLinspace.toIR(), []);
+     * compiled();  // [0.0, 0.1, 0.2, ..., 0.9, 1.0]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Different spacing
+     * const makeLinspace2 = East.function([], ArrayType(FloatType), ($) => {
+     *   $.return(East.Array.linspace(0.0, 10.0, 5n));
+     * });
+     * const compiled = East.compile(makeLinspace2.toIR(), []);
+     * compiled();  // [0.0, 2.5, 5.0, 7.5, 10.0]
+     * ```
+     */
+    linspace(start, stop, size) {
+        const start_val = Expr.from(start, FloatType);
+        const stop_val = Expr.from(stop, FloatType);
+        const count_val = Expr.from(size, IntegerType);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: ArrayType(FloatType),
+            builtin: "ArrayLinspace",
+            type_parameters: [],
+            arguments: [start_val[AstSymbol], stop_val[AstSymbol], count_val[AstSymbol]],
+            location: start_val[AstSymbol].location,
+        });
+    },
+    /**
+     * Generates an array of a given size programmatically with a function from index to value.
+     *
+     * @typeParam T - The type of elements in the generated array
+     * @param size - The size of the array to generate
+     * @param valueType - The East type of the array elements
+     * @param valueFn - A function that takes an index and returns the value at that index
+     * @returns An array expression containing the programmatically generated values
+     *
+     * @example
+     * ```ts
+     * // Generate array [0, 1, 4, 9, 16] (squares)
+     * const makeSquares = East.function([], ArrayType(IntegerType), ($) => {
+     *   $.return(East.Array.generate(5n, IntegerType, ($, i) => i.multiply(i)));
+     * });
+     * const compiled = East.compile(makeSquares.toIR(), []);
+     * compiled();  // [0n, 1n, 4n, 9n, 16n]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Generate array of strings ["Item 0", "Item 1", "Item 2"]
+     * const makeItems = East.function([], ArrayType(StringType), ($) => {
+     *   $.return(East.Array.generate(3n, StringType, ($, i) => Expr.str`Item ${i}`));
+     * });
+     * const compiled = East.compile(makeItems.toIR(), []);
+     * compiled();  // ["Item 0", "Item 1", "Item 2"]
+     * ```
+     */
+    generate(size, valueType, valueFn) {
+        const length_expr = Expr.from(size, IntegerType);
+        const generator_expr = Expr.from(valueFn, FunctionType([IntegerType], valueType, []));
+        const value_type_deduced = generator_expr[TypeSymbol].output;
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: ArrayType(value_type_deduced),
+            builtin: "ArrayGenerate",
+            type_parameters: [value_type_deduced],
+            arguments: [length_expr[AstSymbol], generator_expr[AstSymbol]],
+            location: length_expr[AstSymbol].location,
+        });
+    },
+};
+//# sourceMappingURL=array.js.map

package/dist/src/expr/libs/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","sourceRoot":"","sources":["../../../../src/expr/libs/array.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAiB,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGzD,4CAA4C;AAC5C,eAAe;IACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,KAAK,CAAC,KAAiC,EAAE,GAA+B,EAAE,OAAmC,EAAE;QAC7G,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QAChD,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;QAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC,OAAO,CAAC;YAClB,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,SAAS,CAAC,WAAW,CAAC;YAC5B,OAAO,EAAE,YAAY;YACrB,eAAe,EAAE,EAAE;YACnB,SAAS,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;YAC1E,QAAQ,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC,QAAQ;SACxC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,QAAQ,CAAC,KAA+B,EAAE,IAA8B,EAAE,IAAgC;QACxG,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC5C,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QAC/C,OAAO,IAAI,CAAC,OAAO,CAAC;YAClB,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,SAAS,CAAC,SAAS,CAAC;YAC1B,OAAO,EAAE,eAAe;YACxB,eAAe,EAAE,EAAE;YACnB,SAAS,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;YAC5E,QAAQ,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC,QAAQ;SACxC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,QAAQ,CAAI,IAAgC,EAAE,SAAY,EAAE,OAAoE;QAC9H,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QACjD,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,OAAc,EAAE,YAAY,CAAC,CAAC,WAAW,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC;QAC7F,MAAM,kBAAkB,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC;QAC7D,OAAO,IAAI,CAAC,OAAO,CAAC;YAClB,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,SAAS,CAAC,kBAAkB,CAAC;YACnC,OAAO,EAAE,eAAe;YACxB,eAAe,EAAE,CAAC,kBAA8B,CAAC;YACjD,SAAS,EAAE,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;YAC9D,QAAQ,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC,QAAQ;SAC1C,CAAC,CAAC;IACL,CAAC;CACF,CAAA"}

package/dist/src/expr/libs/blob.d.ts

@@ -0,0 +1,42 @@
+import type { BlobExpr } from "../blob.js";
+import { Expr } from "../expr.js";
+/** Standard library for blobs */
+declare const _default: {
+    /**
+     * Encodes a value to the binary East format (BEAST).
+     *
+     * @param value - The East value to encode
+     * @param version - The BEAST format version to use: `'v1'` or `'v2'` (default: `'v1'`)
+     * @returns A blob expression containing the encoded binary data
+     *
+     * @throws Error when an unsupported version string is provided
+     *
+     * @remarks
+     * BEAST (Binary East) is a compact binary serialization format for East values.
+     * Version 1 (v1) is the original format, while version 2 (v2) provides improved
+     * encoding for certain types.
+     *
+     * @example
+     * ```ts
+     * // Encode an array to BEAST v1 format
+     * const encodeArray = East.function([ArrayType(IntegerType)], BlobType, ($, arr) => {
+     *   $.return(East.Blob.encodeBeast(arr));
+     * });
+     * const compiled = East.compile(encodeArray.toIR(), []);
+     * const blob = compiled([1n, 2n, 3n]);  // Binary blob containing encoded array
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Encode using BEAST v2 format
+     * const encodeV2 = East.function([IntegerType], BlobType, ($, num) => {
+     *   $.return(East.Blob.encodeBeast(num, 'v2'));
+     * });
+     * const compiled = East.compile(encodeV2.toIR(), []);
+     * const blob = compiled(42n);  // Binary blob with v2 encoding
+     * ```
+     */
+    encodeBeast(value: Expr, version?: "v1" | "v2"): BlobExpr;
+};
+export default _default;
+//# sourceMappingURL=blob.d.ts.map

package/dist/src/expr/libs/blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../../../../src/expr/libs/blob.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,iCAAiC;;IAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;uBACgB,IAAI,YAAW,IAAI,GAAG,IAAI,GAAU,QAAQ;;AAnCjE,wBA0DC"}