@elaraai/east 0.0.1-beta.0

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

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { DictType, IntegerType, type EastType, FunctionType } from "../../types.js";
+import { Expr } from "../expr.js";
+import type { SubtypeExprOrValue, ExprType } from "../types.js";
+/** Standard library functions for dictionaries */
+declare const _default: {
+    /**
+     * Generates a dictionary of a given size programmatically with functions from index to key and value.
+     *
+     * @typeParam K - The type of the dictionary keys
+     * @typeParam V - The type of the dictionary values
+     * @param size - The number of entries to generate
+     * @param keyType - The East type of the dictionary keys
+     * @param valueType - The East type of the dictionary values
+     * @param keyFn - A function that takes an index and returns the key at that index
+     * @param valueFn - A function that takes an index and returns the value at that index
+     * @param onConflict - Optional function `(oldValue, newValue, key) => resolvedValue` to handle duplicate keys
+     * @returns A dictionary expression containing the programmatically generated entries
+     *
+     * @throws East runtime error if duplicate keys are produced and no onConflict is provided
+     *
+     * @remarks
+     * If the generator produces duplicate keys, an error will be thrown by default.
+     * To handle duplicates, provide an `onConflict` function that receives the old value,
+     * new value, and the conflicting key, and returns the value to use.
+     *
+     * @example
+     * ```ts
+     * // Generate dict with string keys and integer values
+     * const makeDict = East.function([], DictType(StringType, IntegerType), ($) => {
+     *   $.return(East.Dict.generate(
+     *     3n,
+     *     StringType,
+     *     IntegerType,
+     *     ($, i) => Expr.str`key${i}`,
+     *     ($, i) => i.multiply(10n)
+     *   ));
+     * });
+     * const compiled = East.compile(makeDict.toIR(), []);
+     * compiled();  // { "key0": 0n, "key1": 10n, "key2": 20n }
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Generate dict with conflict resolution (keep larger value)
+     * const makeDictConflict = East.function([], DictType(IntegerType, IntegerType), ($) => {
+     *   $.return(East.Dict.generate(
+     *     5n,
+     *     IntegerType,
+     *     IntegerType,
+     *     ($, i) => i.remainder(3n),  // Creates duplicates: 0,1,2,0,1
+     *     ($, i) => i,
+     *     ($, oldVal, newVal, key) => oldVal.greaterThan(newVal).ifElse(() => oldVal, () => newVal)
+     *   ));
+     * });
+     * const compiled = East.compile(makeDictConflict.toIR(), []);
+     * compiled();  // { 0n: 3n, 1n: 4n, 2n: 2n }
+     * ```
+     */
+    generate<K extends EastType, V extends EastType>(size: Expr<IntegerType> | bigint, keyType: K, valueType: V, keyFn: SubtypeExprOrValue<FunctionType<[IntegerType], NoInfer<K>>>, valueFn: SubtypeExprOrValue<FunctionType<[IntegerType], NoInfer<V>>>, onConflict?: SubtypeExprOrValue<FunctionType<[NoInfer<V>, NoInfer<V>, NoInfer<K>], NoInfer<V>>>): ExprType<DictType<K, V>>;
+};
+export default _default;
+//# sourceMappingURL=dict.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dict.d.ts","sourceRoot":"","sources":["../../../../src/expr/libs/dict.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACpF,OAAO,EAAa,IAAI,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEhE,kDAAkD;;IAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;aACM,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,QAAQ,IAAI,CAAC,WAAW,CAAC,GAAG,MAAM,WAAW,CAAC,aAAa,CAAC,SAAS,kBAAkB,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,kBAAkB,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,eAAe,kBAAkB,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;;AAtDnX,wBAqEC"}

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

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { DictType, IntegerType, FunctionType } from "../../types.js";
+import { AstSymbol, Expr } from "../expr.js";
+/** Standard library functions for dictionaries */
+export default {
+    /**
+     * Generates a dictionary of a given size programmatically with functions from index to key and value.
+     *
+     * @typeParam K - The type of the dictionary keys
+     * @typeParam V - The type of the dictionary values
+     * @param size - The number of entries to generate
+     * @param keyType - The East type of the dictionary keys
+     * @param valueType - The East type of the dictionary values
+     * @param keyFn - A function that takes an index and returns the key at that index
+     * @param valueFn - A function that takes an index and returns the value at that index
+     * @param onConflict - Optional function `(oldValue, newValue, key) => resolvedValue` to handle duplicate keys
+     * @returns A dictionary expression containing the programmatically generated entries
+     *
+     * @throws East runtime error if duplicate keys are produced and no onConflict is provided
+     *
+     * @remarks
+     * If the generator produces duplicate keys, an error will be thrown by default.
+     * To handle duplicates, provide an `onConflict` function that receives the old value,
+     * new value, and the conflicting key, and returns the value to use.
+     *
+     * @example
+     * ```ts
+     * // Generate dict with string keys and integer values
+     * const makeDict = East.function([], DictType(StringType, IntegerType), ($) => {
+     *   $.return(East.Dict.generate(
+     *     3n,
+     *     StringType,
+     *     IntegerType,
+     *     ($, i) => Expr.str`key${i}`,
+     *     ($, i) => i.multiply(10n)
+     *   ));
+     * });
+     * const compiled = East.compile(makeDict.toIR(), []);
+     * compiled();  // { "key0": 0n, "key1": 10n, "key2": 20n }
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Generate dict with conflict resolution (keep larger value)
+     * const makeDictConflict = East.function([], DictType(IntegerType, IntegerType), ($) => {
+     *   $.return(East.Dict.generate(
+     *     5n,
+     *     IntegerType,
+     *     IntegerType,
+     *     ($, i) => i.remainder(3n),  // Creates duplicates: 0,1,2,0,1
+     *     ($, i) => i,
+     *     ($, oldVal, newVal, key) => oldVal.greaterThan(newVal).ifElse(() => oldVal, () => newVal)
+     *   ));
+     * });
+     * const compiled = East.compile(makeDictConflict.toIR(), []);
+     * compiled();  // { 0n: 3n, 1n: 4n, 2n: 2n }
+     * ```
+     */
+    generate(size, keyType, valueType, keyFn, valueFn, onConflict) {
+        const length_expr = Expr.from(size, IntegerType);
+        const key_expr = Expr.from(keyFn, FunctionType([IntegerType], keyType, []));
+        const value_expr = Expr.from(valueFn, FunctionType([IntegerType], valueType, []));
+        const on_conflict_expr = onConflict ? Expr.from(onConflict, FunctionType([valueType, valueType, keyType], valueType, [])) : Expr.function([valueType, valueType, keyType], valueType, ($, _v1, _v2, key) => $.error(Expr.str `Duplicate key ${key} in dict`));
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: DictType(keyType, valueType),
+            builtin: "DictGenerate",
+            type_parameters: [keyType, valueType],
+            arguments: [length_expr[AstSymbol], key_expr[AstSymbol], value_expr[AstSymbol], on_conflict_expr[AstSymbol]],
+            location: length_expr[AstSymbol].location,
+        });
+    },
+};
+//# sourceMappingURL=dict.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dict.js","sourceRoot":"","sources":["../../../../src/expr/libs/dict.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAiB,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACpF,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAG7C,kDAAkD;AAClD,eAAe;IACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACH,QAAQ,CAAyC,IAAgC,EAAE,OAAU,EAAE,SAAY,EAAE,KAAkE,EAAE,OAAoE,EAAE,UAA+F;QACpV,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;QAC5E,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,WAAW,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC;QAClF,MAAM,gBAAgB,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,SAAgB,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAA,iBAAiB,GAAG,UAAU,CAAC,CAAC,CAAC;QAEpQ,OAAO,IAAI,CAAC,OAAO,CAAC;YAClB,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;YAClC,OAAO,EAAE,cAAc;YACvB,eAAe,EAAE,CAAC,OAAO,EAAE,SAAS,CAAC;YACrC,SAAS,EAAE,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;YAC5G,QAAQ,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC,QAAQ;SAC1C,CAAC,CAAC;IACL,CAAC;CACF,CAAA"}

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

@@ -0,0 +1,299 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { BooleanType, FloatType, IntegerType, StringType } from "../../types.js";
+/** Standard library functions for floats */
+declare const _default: {
+    /**
+     * Checks if two floats are approximately equal within an epsilon tolerance.
+     *
+     * @param x - The first float value
+     * @param y - The second float value
+     * @param epsilon - The maximum allowed difference between the values
+     * @returns `true` if the absolute difference between `x` and `y` is less than or equal to `epsilon`
+     *
+     * @example
+     * ```ts
+     * const approxEq = East.function([FloatType, FloatType, FloatType], BooleanType, ($, x, y, eps) => {
+     *   $.return(East.Float.approxEqual(x, y, eps));
+     * });
+     * const compiled = East.compile(approxEq.toIR(), []);
+     * compiled(0.3, 0.1 + 0.2, 0.0001);  // true (handles floating point precision)
+     * compiled(1.0, 1.1, 0.05);          // false
+     * ```
+     */
+    approxEqual: import("../function.js").CallableFunctionExpr<[FloatType, FloatType, FloatType], BooleanType>;
+    /**
+     * Rounds a float down to the nearest integer (floor).
+     *
+     * @param x - The float value to round
+     * @returns The largest integer less than or equal to `x`
+     *
+     * @example
+     * ```ts
+     * const floor = East.function([FloatType], IntegerType, ($, x) => {
+     *   $.return(East.Float.roundFloor(x));
+     * });
+     * const compiled = East.compile(floor.toIR(), []);
+     * compiled(3.7);   // 3n
+     * compiled(-2.3);  // -3n
+     * ```
+     */
+    roundFloor: import("../function.js").CallableFunctionExpr<[FloatType], IntegerType>;
+    /**
+     * Rounds a float up to the nearest integer (ceiling).
+     *
+     * @param x - The float value to round
+     * @returns The smallest integer greater than or equal to `x`
+     *
+     * @example
+     * ```ts
+     * const ceil = East.function([FloatType], IntegerType, ($, x) => {
+     *   $.return(East.Float.roundCeil(x));
+     * });
+     * const compiled = East.compile(ceil.toIR(), []);
+     * compiled(3.2);   // 4n
+     * compiled(-2.7);  // -2n
+     * ```
+     */
+    roundCeil: import("../function.js").CallableFunctionExpr<[FloatType], IntegerType>;
+    /**
+     * Rounds a float to the nearest integer using half-away-from-zero rounding.
+     *
+     * @param x - The float value to round
+     * @returns The nearest integer, with ties (0.5) rounding away from zero
+     *
+     * @example
+     * ```ts
+     * const roundHalf = East.function([FloatType], IntegerType, ($, x) => {
+     *   $.return(East.Float.roundHalf(x));
+     * });
+     * const compiled = East.compile(roundHalf.toIR(), []);
+     * compiled(3.5);   // 4n
+     * compiled(3.4);   // 3n
+     * compiled(-2.5);  // -3n
+     * ```
+     */
+    roundHalf: import("../function.js").CallableFunctionExpr<[FloatType], IntegerType>;
+    /**
+     * Truncates a float towards zero (removes the fractional part).
+     *
+     * @param x - The float value to truncate
+     * @returns The integer part of `x`, discarding the fractional part
+     *
+     * @example
+     * ```ts
+     * const trunc = East.function([FloatType], IntegerType, ($, x) => {
+     *   $.return(East.Float.roundTrunc(x));
+     * });
+     * const compiled = East.compile(trunc.toIR(), []);
+     * compiled(3.7);   // 3n
+     * compiled(-2.7);  // -2n
+     * ```
+     */
+    roundTrunc: import("../function.js").CallableFunctionExpr<[FloatType], IntegerType>;
+    /**
+     * Rounds a float to the nearest multiple of a step value.
+     *
+     * @param x - The float value to round
+     * @param step - The step value to round to (uses absolute value)
+     * @returns The nearest multiple of `step`, with ties rounding away from zero
+     * @throws {Error} When `x` is NaN, Infinity, or -Infinity
+     *
+     * @example
+     * ```ts
+     * const roundNearest = East.function([FloatType, FloatType], FloatType, ($, x, step) => {
+     *   $.return(East.Float.roundNearest(x, step));
+     * });
+     * const compiled = East.compile(roundNearest.toIR(), []);
+     * compiled(17.3, 5.0);     // 15.0
+     * compiled(17.6, 5.0);     // 20.0
+     * compiled(3.14159, 0.01); // 3.14
+     * ```
+     */
+    roundNearest: import("../function.js").CallableFunctionExpr<[FloatType, FloatType], FloatType>;
+    /**
+     * Rounds a float up to the next multiple of a step value (ceiling).
+     *
+     * @param x - The float value to round
+     * @param step - The step value to round to (uses absolute value)
+     * @returns The smallest multiple of `step` greater than or equal to `x`
+     * @throws {Error} When `x` is NaN, Infinity, or -Infinity
+     *
+     * @example
+     * ```ts
+     * const roundUp = East.function([FloatType, FloatType], FloatType, ($, x, step) => {
+     *   $.return(East.Float.roundUp(x, step));
+     * });
+     * const compiled = East.compile(roundUp.toIR(), []);
+     * compiled(17.1, 5.0);  // 20.0
+     * compiled(15.0, 5.0);  // 15.0 (already exact)
+     * compiled(3.14, 0.1);  // 3.2
+     * ```
+     */
+    roundUp: import("../function.js").CallableFunctionExpr<[FloatType, FloatType], FloatType>;
+    /**
+     * Rounds a float down to the previous multiple of a step value (floor).
+     *
+     * @param x - The float value to round
+     * @param step - The step value to round to (uses absolute value)
+     * @returns The largest multiple of `step` less than or equal to `x`
+     * @throws {Error} When `x` is NaN, Infinity, or -Infinity
+     *
+     * @example
+     * ```ts
+     * const roundDown = East.function([FloatType, FloatType], FloatType, ($, x, step) => {
+     *   $.return(East.Float.roundDown(x, step));
+     * });
+     * const compiled = East.compile(roundDown.toIR(), []);
+     * compiled(17.9, 5.0);  // 15.0
+     * compiled(15.0, 5.0);  // 15.0 (already exact)
+     * compiled(3.19, 0.1);  // 3.1
+     * ```
+     */
+    roundDown: import("../function.js").CallableFunctionExpr<[FloatType, FloatType], FloatType>;
+    /**
+     * Rounds a float towards zero to the nearest multiple of a step value (truncate).
+     *
+     * @param x - The float value to round
+     * @param step - The step value to round to (uses absolute value)
+     * @returns The multiple of `step` closest to zero that is between zero and `x`
+     * @throws {Error} When `x` is NaN, Infinity, or -Infinity
+     *
+     * @example
+     * ```ts
+     * const roundTruncate = East.function([FloatType, FloatType], FloatType, ($, x, step) => {
+     *   $.return(East.Float.roundTruncate(x, step));
+     * });
+     * const compiled = East.compile(roundTruncate.toIR(), []);
+     * compiled(17.9, 5.0);   // 15.0
+     * compiled(-17.9, 5.0);  // -15.0
+     * ```
+     */
+    roundTruncate: import("../function.js").CallableFunctionExpr<[FloatType, FloatType], FloatType>;
+    /**
+     * Rounds a float to a specified number of decimal places.
+     *
+     * @param x - The float value to round
+     * @param decimals - The number of decimal places to round to
+     * @returns The float rounded to the specified number of decimal places
+     * @throws {Error} When `x` is NaN, Infinity, or -Infinity
+     *
+     * @example
+     * ```ts
+     * const roundDecimals = East.function([FloatType, IntegerType], FloatType, ($, x, decimals) => {
+     *   $.return(East.Float.roundToDecimals(x, decimals));
+     * });
+     * const compiled = East.compile(roundDecimals.toIR(), []);
+     * compiled(3.14159, 2n);  // 3.14
+     * compiled(2.5, 0n);      // 3.0
+     * ```
+     */
+    roundToDecimals: import("../function.js").CallableFunctionExpr<[FloatType, IntegerType], FloatType>;
+    /**
+     * Formats a float with comma separators for thousands.
+     *
+     * @param x - The float value to format
+     * @param decimals - The number of decimal places to display
+     * @returns A formatted string with comma separators (e.g., `"1,234.567"`)
+     * @throws {Error} When `x` is NaN, Infinity, or -Infinity
+     *
+     * @example
+     * ```ts
+     * const formatComma = East.function([FloatType, IntegerType], StringType, ($, x, decimals) => {
+     *   $.return(East.Float.printCommaSeperated(x, decimals));
+     * });
+     * const compiled = East.compile(formatComma.toIR(), []);
+     * compiled(1234.567, 2n);    // "1,234.57"
+     * compiled(1000000, 0n);     // "1,000,000"
+     * compiled(-5432.1, 3n);     // "-5,432.100"
+     * ```
+     */
+    printCommaSeperated: import("../function.js").CallableFunctionExpr<[FloatType, IntegerType], StringType>;
+    /**
+     * Formats a float as currency with comma separators and 2 decimal places.
+     *
+     * @param x - The float value to format as currency
+     * @returns A formatted currency string (e.g., `"$1,234.56"`)
+     * @throws {Error} When `x` is NaN, Infinity, or -Infinity
+     *
+     * @example
+     * ```ts
+     * const formatCurrency = East.function([FloatType], StringType, ($, x) => {
+     *   $.return(East.Float.printCurrency(x));
+     * });
+     * const compiled = East.compile(formatCurrency.toIR(), []);
+     * compiled(1234.567);   // "$1,234.57"
+     * compiled(-42.5);      // "-$42.50"
+     * compiled(1000000);    // "$1,000,000.00"
+     * ```
+     */
+    printCurrency: import("../function.js").CallableFunctionExpr<[FloatType], StringType>;
+    /**
+     * Formats a float with a fixed number of decimal places.
+     *
+     * @param x - The float value to format
+     * @param decimals - The number of decimal places to display
+     * @returns A formatted string with the specified decimal places (e.g., `"3.14"`)
+     * @throws {Error} When `x` is NaN, Infinity, or -Infinity
+     *
+     * @example
+     * ```ts
+     * const formatFixed = East.function([FloatType, IntegerType], StringType, ($, x, decimals) => {
+     *   $.return(East.Float.printFixed(x, decimals));
+     * });
+     * const compiled = East.compile(formatFixed.toIR(), []);
+     * compiled(3.14159, 2n);  // "3.14"
+     * compiled(42, 3n);       // "42.000"
+     * compiled(-0.5, 1n);     // "-0.5"
+     * ```
+     */
+    printFixed: import("../function.js").CallableFunctionExpr<[FloatType, IntegerType], StringType>;
+    /**
+     * Formats a float in compact form with business unit suffixes.
+     *
+     * Uses suffixes: K (thousands), M (millions), B (billions), T (trillions),
+     * Q (quadrillions), Qi (quintillions).
+     *
+     * @param x - The float value to format
+     * @returns A compact formatted string (e.g., `"21.5K"`, `"1.82M"`, `"314B"`)
+     * @throws {Error} When `x` is NaN, Infinity, or -Infinity
+     *
+     * @example
+     * ```ts
+     * const formatCompact = East.function([FloatType], StringType, ($, x) => {
+     *   $.return(East.Float.printCompact(x));
+     * });
+     * const compiled = East.compile(formatCompact.toIR(), []);
+     * compiled(1500);         // "1.5K"
+     * compiled(2500000);      // "2.5M"
+     * compiled(3140000000);   // "3.14B"
+     * ```
+     */
+    printCompact: import("../function.js").CallableFunctionExpr<[FloatType], StringType>;
+    /**
+     * Formats a float as a percentage.
+     *
+     * Multiplies the value by 100 and appends a percent sign.
+     *
+     * @param x - The float value to format (e.g., `0.452` for 45.2%)
+     * @param decimals - The number of decimal places to display
+     * @returns A formatted percentage string (e.g., `"45.2%"`)
+     * @throws {Error} When `x` is NaN, Infinity, or -Infinity
+     *
+     * @example
+     * ```ts
+     * const formatPercent = East.function([FloatType, IntegerType], StringType, ($, x, decimals) => {
+     *   $.return(East.Float.printPercentage(x, decimals));
+     * });
+     * const compiled = East.compile(formatPercent.toIR(), []);
+     * compiled(0.452, 1n);   // "45.2%"
+     * compiled(0.5, 0n);     // "50%"
+     * compiled(-0.123, 2n);  // "-12.30%"
+     * ```
+     */
+    printPercentage: import("../function.js").CallableFunctionExpr<[FloatType, IntegerType], StringType>;
+};
+export default _default;
+//# sourceMappingURL=float.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"float.d.ts","sourceRoot":"","sources":["../../../../src/expr/libs/float.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjF,4CAA4C;;IAE1C;;;;;;;;;;;;;;;;;OAiBG;;IAMH;;;;;;;;;;;;;;;OAeG;;IAgBH;;;;;;;;;;;;;;;OAeG;;IAiBH;;;;;;;;;;;;;;;;OAgBG;;IAWH;;;;;;;;;;;;;;;OAeG;;IAMH;;;;;;;;;;;;;;;;;;OAkBG;;IA6BH;;;;;;;;;;;;;;;;;;OAkBG;;IA2BH;;;;;;;;;;;;;;;;;;OAkBG;;IA2BH;;;;;;;;;;;;;;;;;OAiBG;;IAgBH;;;;;;;;;;;;;;;;;OAiBG;;IAiCH;;;;;;;;;;;;;;;;;;OAkBG;;IA8EH;;;;;;;;;;;;;;;;;OAiBG;;IA0DH;;;;;;;;;;;;;;;;;;OAkBG;;IA8CH;;;;;;;;;;;;;;;;;;;;OAoBG;;IA2DH;;;;;;;;;;;;;;;;;;;;OAoBG;;;AAjrBL,wBA8sBC"}