@elaraai/east 1.0.84 → 1.0.86

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

@@ -4,8 +4,9 @@
  */
 import { BooleanType, FloatType, IntegerType, StringType } from "../../types.js";
 import { Expr } from "../expr.js";
+import { lazyLibrary } from "./lazy.js";
 /** Standard library functions for floats */
-export default {
+export default lazyLibrary({
     /**
      * Checks if two floats are approximately equal within an epsilon tolerance.
      *
@@ -24,10 +25,12 @@ export default {
      * compiled(1.0, 1.1, 0.05);          // false
      * ```
      */
-    approxEqual: Expr.function([FloatType, FloatType, FloatType], BooleanType, ($, x, y, epsilon) => {
-        const diff = $.let(x.subtract(y).abs());
-        $.return(Expr.lessEqual(diff, epsilon));
-    }),
+    get approxEqual() {
+        return Expr.function([FloatType, FloatType, FloatType], BooleanType, ($, x, y, epsilon) => {
+            const diff = $.let(x.subtract(y).abs());
+            $.return(Expr.lessEqual(diff, epsilon));
+        });
+    },
     /**
      * Rounds a float down to the nearest integer (floor).
      *
@@ -44,12 +47,14 @@ export default {
      * compiled(-2.3);  // -3n
      * ```
      */
-    roundFloor: Expr.function([FloatType], IntegerType, ($, x) => {
-        const rem = $.let(x.remainder(1.0));
-        const is_exact = $.let(Expr.equal(rem, 0.0).bitOr(Expr.equal(rem, -0.0)));
-        const floored_float = $.let(is_exact.ifElse(() => x, () => Expr.greaterEqual(x, 0.0).ifElse(() => x.subtract(rem), () => x.subtract(rem).subtract(1.0))));
-        $.return(floored_float.toInteger());
-    }),
+    get roundFloor() {
+        return Expr.function([FloatType], IntegerType, ($, x) => {
+            const rem = $.let(x.remainder(1.0));
+            const is_exact = $.let(Expr.equal(rem, 0.0).bitOr(Expr.equal(rem, -0.0)));
+            const floored_float = $.let(is_exact.ifElse(() => x, () => Expr.greaterEqual(x, 0.0).ifElse(() => x.subtract(rem), () => x.subtract(rem).subtract(1.0))));
+            $.return(floored_float.toInteger());
+        });
+    },
     /**
      * Rounds a float up to the nearest integer (ceiling).
      *
@@ -66,13 +71,15 @@ export default {
      * compiled(-2.7);  // -2n
      * ```
      */
-    roundCeil: Expr.function([FloatType], IntegerType, ($, x) => {
-        // Use the step-based roundUp with step=1.0, then convert
-        const rem = $.let(x.remainder(1.0));
-        const is_exact = $.let(Expr.equal(rem, 0.0).bitOr(Expr.equal(rem, -0.0)));
-        const ceiled_float = $.let(is_exact.ifElse(() => x, () => Expr.greaterEqual(x, 0.0).ifElse(() => x.subtract(rem).add(1.0), () => x.subtract(rem))));
-        $.return(ceiled_float.toInteger());
-    }),
+    get roundCeil() {
+        return Expr.function([FloatType], IntegerType, ($, x) => {
+            // Use the step-based roundUp with step=1.0, then convert
+            const rem = $.let(x.remainder(1.0));
+            const is_exact = $.let(Expr.equal(rem, 0.0).bitOr(Expr.equal(rem, -0.0)));
+            const ceiled_float = $.let(is_exact.ifElse(() => x, () => Expr.greaterEqual(x, 0.0).ifElse(() => x.subtract(rem).add(1.0), () => x.subtract(rem))));
+            $.return(ceiled_float.toInteger());
+        });
+    },
     /**
      * Rounds a float to the nearest integer using half-away-from-zero rounding.
      *
@@ -90,10 +97,12 @@ export default {
      * compiled(-2.5);  // -3n
      * ```
      */
-    roundHalf: Expr.function([FloatType], IntegerType, ($, x) => {
-        const rounded_float = $.let(Expr.greaterEqual(x, 0.0).ifElse(() => x.add(0.5).subtract(x.add(0.5).remainder(1.0)), () => x.subtract(0.5).subtract(x.subtract(0.5).remainder(1.0))));
-        $.return(rounded_float.toInteger());
-    }),
+    get roundHalf() {
+        return Expr.function([FloatType], IntegerType, ($, x) => {
+            const rounded_float = $.let(Expr.greaterEqual(x, 0.0).ifElse(() => x.add(0.5).subtract(x.add(0.5).remainder(1.0)), () => x.subtract(0.5).subtract(x.subtract(0.5).remainder(1.0))));
+            $.return(rounded_float.toInteger());
+        });
+    },
     /**
      * Truncates a float towards zero (removes the fractional part).
      *
@@ -110,10 +119,12 @@ export default {
      * compiled(-2.7);  // -2n
      * ```
      */
-    roundTrunc: Expr.function([FloatType], IntegerType, ($, x) => {
-        const truncated_float = $.let(x.subtract(x.remainder(1.0)));
-        $.return(truncated_float.toInteger());
-    }),
+    get roundTrunc() {
+        return Expr.function([FloatType], IntegerType, ($, x) => {
+            const truncated_float = $.let(x.subtract(x.remainder(1.0)));
+            $.return(truncated_float.toInteger());
+        });
+    },
     /**
      * Rounds a float to the nearest multiple of a step value.
      *
@@ -133,24 +144,26 @@ export default {
      * compiled(3.14159, 0.01); // 3.14
      * ```
      */
-    roundNearest: Expr.function([FloatType, FloatType], FloatType, ($, x, step) => {
-        // Check for NaN/Infinity
-        $.if(Expr.equal(x, NaN), $ => $.error("Cannot round NaN"));
-        $.if(Expr.equal(x, Infinity), $ => $.error("Cannot round Infinity"));
-        $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot round -Infinity"));
-        $.if(Expr.equal(step, 0.0), $ => $.return(x));
-        const abs_step = $.let(step.abs());
-        const divisions = $.let(x.divide(abs_step));
-        // Round to nearest integer multiple
-        const rounded_divisions_float = $.let(Expr.greaterEqual(divisions, 0.0).ifElse(() => {
-            const shifted = divisions.add(0.5);
-            return shifted.subtract(shifted.remainder(1.0));
-        }, () => {
-            const shifted = divisions.subtract(0.5);
-            return shifted.subtract(shifted.remainder(1.0));
-        }));
-        $.return(rounded_divisions_float.multiply(abs_step));
-    }),
+    get roundNearest() {
+        return Expr.function([FloatType, FloatType], FloatType, ($, x, step) => {
+            // Check for NaN/Infinity
+            $.if(Expr.equal(x, NaN), $ => $.error("Cannot round NaN"));
+            $.if(Expr.equal(x, Infinity), $ => $.error("Cannot round Infinity"));
+            $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot round -Infinity"));
+            $.if(Expr.equal(step, 0.0), $ => $.return(x));
+            const abs_step = $.let(step.abs());
+            const divisions = $.let(x.divide(abs_step));
+            // Round to nearest integer multiple
+            const rounded_divisions_float = $.let(Expr.greaterEqual(divisions, 0.0).ifElse(() => {
+                const shifted = divisions.add(0.5);
+                return shifted.subtract(shifted.remainder(1.0));
+            }, () => {
+                const shifted = divisions.subtract(0.5);
+                return shifted.subtract(shifted.remainder(1.0));
+            }));
+            $.return(rounded_divisions_float.multiply(abs_step));
+        });
+    },
     /**
      * Rounds a float up to the next multiple of a step value (ceiling).
      *
@@ -170,22 +183,24 @@ export default {
      * compiled(3.14, 0.1);  // 3.2
      * ```
      */
-    roundUp: Expr.function([FloatType, FloatType], FloatType, ($, x, step) => {
-        // Check for NaN/Infinity
-        $.if(Expr.equal(x, NaN), $ => $.error("Cannot round NaN"));
-        $.if(Expr.equal(x, Infinity), $ => $.error("Cannot round Infinity"));
-        $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot round -Infinity"));
-        $.if(Expr.equal(step, 0.0), $ => $.return(x));
-        const abs_step = $.let(step.abs());
-        const divisions = $.let(x.divide(abs_step));
-        const rem = $.let(divisions.remainder(1.0));
-        // Check if already exact
-        const is_exact = $.let(Expr.equal(rem, 0.0).bitOr(Expr.equal(rem, -0.0)));
-        $.if(is_exact, $ => $.return(x));
-        // Round up
-        const ceiled = $.let(Expr.greaterEqual(x, 0.0).ifElse(() => divisions.subtract(rem).add(1.0), () => divisions.subtract(rem)));
-        $.return(ceiled.multiply(abs_step));
-    }),
+    get roundUp() {
+        return Expr.function([FloatType, FloatType], FloatType, ($, x, step) => {
+            // Check for NaN/Infinity
+            $.if(Expr.equal(x, NaN), $ => $.error("Cannot round NaN"));
+            $.if(Expr.equal(x, Infinity), $ => $.error("Cannot round Infinity"));
+            $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot round -Infinity"));
+            $.if(Expr.equal(step, 0.0), $ => $.return(x));
+            const abs_step = $.let(step.abs());
+            const divisions = $.let(x.divide(abs_step));
+            const rem = $.let(divisions.remainder(1.0));
+            // Check if already exact
+            const is_exact = $.let(Expr.equal(rem, 0.0).bitOr(Expr.equal(rem, -0.0)));
+            $.if(is_exact, $ => $.return(x));
+            // Round up
+            const ceiled = $.let(Expr.greaterEqual(x, 0.0).ifElse(() => divisions.subtract(rem).add(1.0), () => divisions.subtract(rem)));
+            $.return(ceiled.multiply(abs_step));
+        });
+    },
     /**
      * Rounds a float down to the previous multiple of a step value (floor).
      *
@@ -205,22 +220,24 @@ export default {
      * compiled(3.19, 0.1);  // 3.1
      * ```
      */
-    roundDown: Expr.function([FloatType, FloatType], FloatType, ($, x, step) => {
-        // Check for NaN/Infinity
-        $.if(Expr.equal(x, NaN), $ => $.error("Cannot round NaN"));
-        $.if(Expr.equal(x, Infinity), $ => $.error("Cannot round Infinity"));
-        $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot round -Infinity"));
-        $.if(Expr.equal(step, 0.0), $ => $.return(x));
-        const abs_step = $.let(step.abs());
-        const divisions = $.let(x.divide(abs_step));
-        const rem = $.let(divisions.remainder(1.0));
-        // Check if already exact
-        const is_exact = $.let(Expr.equal(rem, 0.0).bitOr(Expr.equal(rem, -0.0)));
-        $.if(is_exact, $ => $.return(x));
-        // Round down
-        const floored = $.let(Expr.greaterEqual(x, 0.0).ifElse(() => divisions.subtract(rem), () => divisions.subtract(rem).subtract(1.0)));
-        $.return(floored.multiply(abs_step));
-    }),
+    get roundDown() {
+        return Expr.function([FloatType, FloatType], FloatType, ($, x, step) => {
+            // Check for NaN/Infinity
+            $.if(Expr.equal(x, NaN), $ => $.error("Cannot round NaN"));
+            $.if(Expr.equal(x, Infinity), $ => $.error("Cannot round Infinity"));
+            $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot round -Infinity"));
+            $.if(Expr.equal(step, 0.0), $ => $.return(x));
+            const abs_step = $.let(step.abs());
+            const divisions = $.let(x.divide(abs_step));
+            const rem = $.let(divisions.remainder(1.0));
+            // Check if already exact
+            const is_exact = $.let(Expr.equal(rem, 0.0).bitOr(Expr.equal(rem, -0.0)));
+            $.if(is_exact, $ => $.return(x));
+            // Round down
+            const floored = $.let(Expr.greaterEqual(x, 0.0).ifElse(() => divisions.subtract(rem), () => divisions.subtract(rem).subtract(1.0)));
+            $.return(floored.multiply(abs_step));
+        });
+    },
     /**
      * Rounds a float towards zero to the nearest multiple of a step value (truncate).
      *
@@ -239,17 +256,19 @@ export default {
      * compiled(-17.9, 5.0);  // -15.0
      * ```
      */
-    roundTruncate: Expr.function([FloatType, FloatType], FloatType, ($, x, step) => {
-        // Check for NaN/Infinity
-        $.if(Expr.equal(x, NaN), $ => $.error("Cannot round NaN"));
-        $.if(Expr.equal(x, Infinity), $ => $.error("Cannot round Infinity"));
-        $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot round -Infinity"));
-        $.if(Expr.equal(step, 0.0), $ => $.return(x));
-        const abs_step = $.let(step.abs());
-        const divisions = $.let(x.divide(abs_step));
-        const truncated = $.let(divisions.subtract(divisions.remainder(1.0)));
-        $.return(truncated.multiply(abs_step));
-    }),
+    get roundTruncate() {
+        return Expr.function([FloatType, FloatType], FloatType, ($, x, step) => {
+            // Check for NaN/Infinity
+            $.if(Expr.equal(x, NaN), $ => $.error("Cannot round NaN"));
+            $.if(Expr.equal(x, Infinity), $ => $.error("Cannot round Infinity"));
+            $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot round -Infinity"));
+            $.if(Expr.equal(step, 0.0), $ => $.return(x));
+            const abs_step = $.let(step.abs());
+            const divisions = $.let(x.divide(abs_step));
+            const truncated = $.let(divisions.subtract(divisions.remainder(1.0)));
+            $.return(truncated.multiply(abs_step));
+        });
+    },
     /**
      * Rounds a float to a specified number of decimal places.
      *
@@ -268,28 +287,30 @@ export default {
      * compiled(2.5, 0n);      // 3.0
      * ```
      */
-    roundToDecimals: Expr.function([FloatType, IntegerType], FloatType, ($, x, decimals) => {
-        // Check for NaN/Infinity
-        $.if(Expr.equal(x, NaN), $ => $.error("Cannot round NaN"));
-        $.if(Expr.equal(x, Infinity), $ => $.error("Cannot round Infinity"));
-        $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot round -Infinity"));
-        // Build multiplier as 10^decimals iteratively
-        const remaining = $.let(decimals);
-        const multiplier = $.let(1.0);
-        $.while(Expr.greater(remaining, 0n), $ => {
-            $.assign(multiplier, multiplier.multiply(10.0));
-            $.assign(remaining, remaining.subtract(1n));
+    get roundToDecimals() {
+        return Expr.function([FloatType, IntegerType], FloatType, ($, x, decimals) => {
+            // Check for NaN/Infinity
+            $.if(Expr.equal(x, NaN), $ => $.error("Cannot round NaN"));
+            $.if(Expr.equal(x, Infinity), $ => $.error("Cannot round Infinity"));
+            $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot round -Infinity"));
+            // Build multiplier as 10^decimals iteratively
+            const remaining = $.let(decimals);
+            const multiplier = $.let(1.0);
+            $.while(Expr.greater(remaining, 0n), $ => {
+                $.assign(multiplier, multiplier.multiply(10.0));
+                $.assign(remaining, remaining.subtract(1n));
+            });
+            const scaled = $.let(x.multiply(multiplier));
+            const rounded = $.let(Expr.greaterEqual(scaled, 0.0).ifElse(() => {
+                const shifted = scaled.add(0.5);
+                return shifted.subtract(shifted.remainder(1.0));
+            }, () => {
+                const shifted = scaled.subtract(0.5);
+                return shifted.subtract(shifted.remainder(1.0));
+            }));
+            $.return(rounded.divide(multiplier));
         });
-        const scaled = $.let(x.multiply(multiplier));
-        const rounded = $.let(Expr.greaterEqual(scaled, 0.0).ifElse(() => {
-            const shifted = scaled.add(0.5);
-            return shifted.subtract(shifted.remainder(1.0));
-        }, () => {
-            const shifted = scaled.subtract(0.5);
-            return shifted.subtract(shifted.remainder(1.0));
-        }));
-        $.return(rounded.divide(multiplier));
-    }),
+    },
     /**
      * Formats a float with comma separators for thousands.
      *
@@ -309,55 +330,57 @@ export default {
      * compiled(-5432.1, 3n);     // "-5,432.100"
      * ```
      */
-    printCommaSeperated: Expr.function([FloatType, IntegerType], StringType, ($, x, decimals) => {
-        // Check for NaN/Infinity
-        $.if(Expr.equal(x, NaN), $ => $.error("Cannot format NaN"));
-        $.if(Expr.equal(x, Infinity), $ => $.error("Cannot format Infinity"));
-        $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot format -Infinity"));
-        const negative = $.let(Expr.less(x, 0.0));
-        const abs_x = $.let(x.abs());
-        // Build multiplier for rounding
-        const remaining = $.let(decimals);
-        const multiplier = $.let(1.0);
-        $.while(Expr.greater(remaining, 0n), $ => {
-            $.assign(multiplier, multiplier.multiply(10.0));
-            $.assign(remaining, remaining.subtract(1n));
-        });
-        // Round and split
-        const scaled = $.let(abs_x.multiply(multiplier));
-        const shifted = $.let(scaled.add(0.5));
-        const rounded_scaled_float = $.let(shifted.subtract(shifted.remainder(1.0)));
-        const rounded_scaled = $.let(rounded_scaled_float.toInteger());
-        const integer_part = $.let(rounded_scaled.divide(multiplier.toInteger()));
-        const frac_part = $.let(rounded_scaled.remainder(multiplier.toInteger()));
-        // Format integer with commas
-        const int_with_commas = $.let(integer_part);
-        const comma_ret = $.let("");
-        $.while(Expr.greater(int_with_commas, 999n), $ => {
-            const z = $.let(int_with_commas.remainder(1000n));
-            $.if(Expr.less(z, 10n), $ => {
-                $.assign(comma_ret, Expr.str `,00${z}${comma_ret}`);
-            }).else($ => {
-                $.if(Expr.less(z, 100n), $ => {
-                    $.assign(comma_ret, Expr.str `,0${z}${comma_ret}`);
+    get printCommaSeperated() {
+        return Expr.function([FloatType, IntegerType], StringType, ($, x, decimals) => {
+            // Check for NaN/Infinity
+            $.if(Expr.equal(x, NaN), $ => $.error("Cannot format NaN"));
+            $.if(Expr.equal(x, Infinity), $ => $.error("Cannot format Infinity"));
+            $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot format -Infinity"));
+            const negative = $.let(Expr.less(x, 0.0));
+            const abs_x = $.let(x.abs());
+            // Build multiplier for rounding
+            const remaining = $.let(decimals);
+            const multiplier = $.let(1.0);
+            $.while(Expr.greater(remaining, 0n), $ => {
+                $.assign(multiplier, multiplier.multiply(10.0));
+                $.assign(remaining, remaining.subtract(1n));
+            });
+            // Round and split
+            const scaled = $.let(abs_x.multiply(multiplier));
+            const shifted = $.let(scaled.add(0.5));
+            const rounded_scaled_float = $.let(shifted.subtract(shifted.remainder(1.0)));
+            const rounded_scaled = $.let(rounded_scaled_float.toInteger());
+            const integer_part = $.let(rounded_scaled.divide(multiplier.toInteger()));
+            const frac_part = $.let(rounded_scaled.remainder(multiplier.toInteger()));
+            // Format integer with commas
+            const int_with_commas = $.let(integer_part);
+            const comma_ret = $.let("");
+            $.while(Expr.greater(int_with_commas, 999n), $ => {
+                const z = $.let(int_with_commas.remainder(1000n));
+                $.if(Expr.less(z, 10n), $ => {
+                    $.assign(comma_ret, Expr.str `,00${z}${comma_ret}`);
                 }).else($ => {
-                    $.assign(comma_ret, Expr.str `,${z}${comma_ret}`);
+                    $.if(Expr.less(z, 100n), $ => {
+                        $.assign(comma_ret, Expr.str `,0${z}${comma_ret}`);
+                    }).else($ => {
+                        $.assign(comma_ret, Expr.str `,${z}${comma_ret}`);
+                    });
                 });
+                $.assign(int_with_commas, int_with_commas.divide(1000n));
             });
-            $.assign(int_with_commas, int_with_commas.divide(1000n));
-        });
-        const int_str = $.let(Expr.str `${int_with_commas}${comma_ret}`);
-        // Format fractional part with padding
-        const frac_str = $.let(Expr.str `${frac_part}`);
-        const padding_needed = $.let(decimals.subtract(frac_str.length()));
-        const padding = $.let("");
-        $.while(Expr.greater(padding_needed, 0n), $ => {
-            $.assign(padding, Expr.str `0${padding}`);
-            $.assign(padding_needed, padding_needed.subtract(1n));
+            const int_str = $.let(Expr.str `${int_with_commas}${comma_ret}`);
+            // Format fractional part with padding
+            const frac_str = $.let(Expr.str `${frac_part}`);
+            const padding_needed = $.let(decimals.subtract(frac_str.length()));
+            const padding = $.let("");
+            $.while(Expr.greater(padding_needed, 0n), $ => {
+                $.assign(padding, Expr.str `0${padding}`);
+                $.assign(padding_needed, padding_needed.subtract(1n));
+            });
+            const result = $.let(Expr.equal(decimals, 0n).ifElse(() => int_str, () => Expr.str `${int_str}.${padding}${frac_str}`));
+            $.return(negative.ifElse(() => Expr.str `-${result}`, () => result));
         });
-        const result = $.let(Expr.equal(decimals, 0n).ifElse(() => int_str, () => Expr.str `${int_str}.${padding}${frac_str}`));
-        $.return(negative.ifElse(() => Expr.str `-${result}`, () => result));
-    }),
+    },
     /**
      * Formats a float as currency with comma separators and 2 decimal places.
      *
@@ -376,40 +399,42 @@ export default {
      * compiled(1000000);    // "$1,000,000.00"
      * ```
      */
-    printCurrency: Expr.function([FloatType], StringType, ($, x) => {
-        // Check for NaN/Infinity
-        $.if(Expr.equal(x, NaN), $ => $.error("Cannot format NaN"));
-        $.if(Expr.equal(x, Infinity), $ => $.error("Cannot format Infinity"));
-        $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot format -Infinity"));
-        const negative = $.let(Expr.less(x, 0.0));
-        const abs_x = $.let(x.abs());
-        // Round to cents
-        const shifted = $.let(abs_x.multiply(100.0).add(0.5));
-        const cents_total_float = $.let(shifted.subtract(shifted.remainder(1.0)));
-        const cents_total = $.let(cents_total_float.toInteger());
-        const dollars = $.let(cents_total.divide(100n));
-        const cents = $.let(cents_total.remainder(100n));
-        // Format dollars with commas
-        const dollars_with_commas = $.let(dollars);
-        const comma_ret = $.let("");
-        $.while(Expr.greater(dollars_with_commas, 999n), $ => {
-            const z = $.let(dollars_with_commas.remainder(1000n));
-            $.if(Expr.less(z, 10n), $ => {
-                $.assign(comma_ret, Expr.str `,00${z}${comma_ret}`);
-            }).else($ => {
-                $.if(Expr.less(z, 100n), $ => {
-                    $.assign(comma_ret, Expr.str `,0${z}${comma_ret}`);
+    get printCurrency() {
+        return Expr.function([FloatType], StringType, ($, x) => {
+            // Check for NaN/Infinity
+            $.if(Expr.equal(x, NaN), $ => $.error("Cannot format NaN"));
+            $.if(Expr.equal(x, Infinity), $ => $.error("Cannot format Infinity"));
+            $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot format -Infinity"));
+            const negative = $.let(Expr.less(x, 0.0));
+            const abs_x = $.let(x.abs());
+            // Round to cents
+            const shifted = $.let(abs_x.multiply(100.0).add(0.5));
+            const cents_total_float = $.let(shifted.subtract(shifted.remainder(1.0)));
+            const cents_total = $.let(cents_total_float.toInteger());
+            const dollars = $.let(cents_total.divide(100n));
+            const cents = $.let(cents_total.remainder(100n));
+            // Format dollars with commas
+            const dollars_with_commas = $.let(dollars);
+            const comma_ret = $.let("");
+            $.while(Expr.greater(dollars_with_commas, 999n), $ => {
+                const z = $.let(dollars_with_commas.remainder(1000n));
+                $.if(Expr.less(z, 10n), $ => {
+                    $.assign(comma_ret, Expr.str `,00${z}${comma_ret}`);
                 }).else($ => {
-                    $.assign(comma_ret, Expr.str `,${z}${comma_ret}`);
+                    $.if(Expr.less(z, 100n), $ => {
+                        $.assign(comma_ret, Expr.str `,0${z}${comma_ret}`);
+                    }).else($ => {
+                        $.assign(comma_ret, Expr.str `,${z}${comma_ret}`);
+                    });
                 });
+                $.assign(dollars_with_commas, dollars_with_commas.divide(1000n));
             });
-            $.assign(dollars_with_commas, dollars_with_commas.divide(1000n));
+            const dollars_str = $.let(Expr.str `${dollars_with_commas}${comma_ret}`);
+            const cents_str = $.let(Expr.less(cents, 10n).ifElse(() => Expr.str `0${cents}`, () => Expr.str `${cents}`));
+            const result = $.let(Expr.str `${dollars_str}.${cents_str}`);
+            $.return(negative.ifElse(() => Expr.str `-$${result}`, () => Expr.str `$${result}`));
         });
-        const dollars_str = $.let(Expr.str `${dollars_with_commas}${comma_ret}`);
-        const cents_str = $.let(Expr.less(cents, 10n).ifElse(() => Expr.str `0${cents}`, () => Expr.str `${cents}`));
-        const result = $.let(Expr.str `${dollars_str}.${cents_str}`);
-        $.return(negative.ifElse(() => Expr.str `-$${result}`, () => Expr.str `$${result}`));
-    }),
+    },
     /**
      * Formats a float with a fixed number of decimal places.
      *
@@ -429,38 +454,40 @@ export default {
      * compiled(-0.5, 1n);     // "-0.5"
      * ```
      */
-    printFixed: Expr.function([FloatType, IntegerType], StringType, ($, x, decimals) => {
-        // Check for NaN/Infinity
-        $.if(Expr.equal(x, NaN), $ => $.error("Cannot format NaN"));
-        $.if(Expr.equal(x, Infinity), $ => $.error("Cannot format Infinity"));
-        $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot format -Infinity"));
-        const negative = $.let(Expr.less(x, 0.0));
-        const abs_x = $.let(x.abs());
-        // Build multiplier
-        const remaining = $.let(decimals);
-        const multiplier = $.let(1.0);
-        $.while(Expr.greater(remaining, 0n), $ => {
-            $.assign(multiplier, multiplier.multiply(10.0));
-            $.assign(remaining, remaining.subtract(1n));
-        });
-        // Round and split
-        const scaled = $.let(abs_x.multiply(multiplier));
-        const shifted = $.let(scaled.add(0.5));
-        const rounded_scaled_float = $.let(shifted.subtract(shifted.remainder(1.0)));
-        const rounded_scaled = $.let(rounded_scaled_float.toInteger());
-        const integer_part = $.let(rounded_scaled.divide(multiplier.toInteger()));
-        const frac_part = $.let(rounded_scaled.remainder(multiplier.toInteger()));
-        // Format fractional part with padding
-        const frac_str = $.let(Expr.str `${frac_part}`);
-        const padding_needed = $.let(decimals.subtract(frac_str.length()));
-        const padding = $.let("");
-        $.while(Expr.greater(padding_needed, 0n), $ => {
-            $.assign(padding, Expr.str `0${padding}`);
-            $.assign(padding_needed, padding_needed.subtract(1n));
+    get printFixed() {
+        return Expr.function([FloatType, IntegerType], StringType, ($, x, decimals) => {
+            // Check for NaN/Infinity
+            $.if(Expr.equal(x, NaN), $ => $.error("Cannot format NaN"));
+            $.if(Expr.equal(x, Infinity), $ => $.error("Cannot format Infinity"));
+            $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot format -Infinity"));
+            const negative = $.let(Expr.less(x, 0.0));
+            const abs_x = $.let(x.abs());
+            // Build multiplier
+            const remaining = $.let(decimals);
+            const multiplier = $.let(1.0);
+            $.while(Expr.greater(remaining, 0n), $ => {
+                $.assign(multiplier, multiplier.multiply(10.0));
+                $.assign(remaining, remaining.subtract(1n));
+            });
+            // Round and split
+            const scaled = $.let(abs_x.multiply(multiplier));
+            const shifted = $.let(scaled.add(0.5));
+            const rounded_scaled_float = $.let(shifted.subtract(shifted.remainder(1.0)));
+            const rounded_scaled = $.let(rounded_scaled_float.toInteger());
+            const integer_part = $.let(rounded_scaled.divide(multiplier.toInteger()));
+            const frac_part = $.let(rounded_scaled.remainder(multiplier.toInteger()));
+            // Format fractional part with padding
+            const frac_str = $.let(Expr.str `${frac_part}`);
+            const padding_needed = $.let(decimals.subtract(frac_str.length()));
+            const padding = $.let("");
+            $.while(Expr.greater(padding_needed, 0n), $ => {
+                $.assign(padding, Expr.str `0${padding}`);
+                $.assign(padding_needed, padding_needed.subtract(1n));
+            });
+            const result = $.let(Expr.equal(decimals, 0n).ifElse(() => Expr.str `${integer_part}`, () => Expr.str `${integer_part}.${padding}${frac_str}`));
+            $.return(negative.ifElse(() => Expr.str `-${result}`, () => result));
         });
-        const result = $.let(Expr.equal(decimals, 0n).ifElse(() => Expr.str `${integer_part}`, () => Expr.str `${integer_part}.${padding}${frac_str}`));
-        $.return(negative.ifElse(() => Expr.str `-${result}`, () => result));
-    }),
+    },
     /**
      * Formats a float in compact form with business unit suffixes.
      *
@@ -482,44 +509,46 @@ export default {
      * compiled(3140000000);   // "3.14B"
      * ```
      */
-    printCompact: Expr.function([FloatType], StringType, ($, x) => {
-        // Check for NaN/Infinity
-        $.if(Expr.equal(x, NaN), $ => $.error("Cannot format NaN"));
-        $.if(Expr.equal(x, Infinity), $ => $.error("Cannot format Infinity"));
-        $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot format -Infinity"));
-        const negative = $.let(Expr.less(x, 0.0));
-        const y = $.let(x.abs());
-        $.if(Expr.less(y, 1000.0), $ => {
-            const shifted = $.let(y.add(0.5));
+    get printCompact() {
+        return Expr.function([FloatType], StringType, ($, x) => {
+            // Check for NaN/Infinity
+            $.if(Expr.equal(x, NaN), $ => $.error("Cannot format NaN"));
+            $.if(Expr.equal(x, Infinity), $ => $.error("Cannot format Infinity"));
+            $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot format -Infinity"));
+            const negative = $.let(Expr.less(x, 0.0));
+            const y = $.let(x.abs());
+            $.if(Expr.less(y, 1000.0), $ => {
+                const shifted = $.let(y.add(0.5));
+                const rounded_int = $.let(shifted.subtract(shifted.remainder(1.0)));
+                const rounded = $.let(rounded_int.divide(100.0));
+                $.return(negative.ifElse(() => Expr.str `-${rounded}`, () => Expr.str `${rounded}`));
+            });
+            const scale = $.let(1n);
+            const scaled = $.let(y);
+            $.while(Expr.greaterEqual(scaled, 1000000.0), $ => {
+                $.assign(scaled, scaled.divide(1000.0));
+                $.assign(scale, scale.add(1n));
+            });
+            const suffix = $.let(Expr.equal(scale, 1n).ifElse(() => "K", () => Expr.equal(scale, 2n).ifElse(() => "M", () => Expr.equal(scale, 3n).ifElse(() => "B", () => Expr.equal(scale, 4n).ifElse(() => "T", () => Expr.equal(scale, 5n).ifElse(() => "Q", () => "Qi"))))));
+            const div = $.let(scaled.divide(1000.0));
+            $.if(Expr.greaterEqual(scaled, 100000.0), $ => {
+                const shifted = $.let(div.add(0.5));
+                const rounded_float = $.let(shifted.subtract(shifted.remainder(1.0)));
+                const rounded = $.let(rounded_float.toInteger());
+                $.return(negative.ifElse(() => Expr.str `-${rounded}${suffix}`, () => Expr.str `${rounded}${suffix}`));
+            });
+            $.if(Expr.greaterEqual(scaled, 10000.0), $ => {
+                const shifted = $.let(div.multiply(10.0).add(0.5));
+                const rounded_int = $.let(shifted.subtract(shifted.remainder(1.0)));
+                const rounded = $.let(rounded_int.divide(10.0));
+                $.return(negative.ifElse(() => Expr.str `-${rounded}${suffix}`, () => Expr.str `${rounded}${suffix}`));
+            });
+            const shifted = $.let(div.multiply(100.0).add(0.5));
             const rounded_int = $.let(shifted.subtract(shifted.remainder(1.0)));
             const rounded = $.let(rounded_int.divide(100.0));
-            $.return(negative.ifElse(() => Expr.str `-${rounded}`, () => Expr.str `${rounded}`));
-        });
-        const scale = $.let(1n);
-        const scaled = $.let(y);
-        $.while(Expr.greaterEqual(scaled, 1000000.0), $ => {
-            $.assign(scaled, scaled.divide(1000.0));
-            $.assign(scale, scale.add(1n));
-        });
-        const suffix = $.let(Expr.equal(scale, 1n).ifElse(() => "K", () => Expr.equal(scale, 2n).ifElse(() => "M", () => Expr.equal(scale, 3n).ifElse(() => "B", () => Expr.equal(scale, 4n).ifElse(() => "T", () => Expr.equal(scale, 5n).ifElse(() => "Q", () => "Qi"))))));
-        const div = $.let(scaled.divide(1000.0));
-        $.if(Expr.greaterEqual(scaled, 100000.0), $ => {
-            const shifted = $.let(div.add(0.5));
-            const rounded_float = $.let(shifted.subtract(shifted.remainder(1.0)));
-            const rounded = $.let(rounded_float.toInteger());
             $.return(negative.ifElse(() => Expr.str `-${rounded}${suffix}`, () => Expr.str `${rounded}${suffix}`));
         });
-        $.if(Expr.greaterEqual(scaled, 10000.0), $ => {
-            const shifted = $.let(div.multiply(10.0).add(0.5));
-            const rounded_int = $.let(shifted.subtract(shifted.remainder(1.0)));
-            const rounded = $.let(rounded_int.divide(10.0));
-            $.return(negative.ifElse(() => Expr.str `-${rounded}${suffix}`, () => Expr.str `${rounded}${suffix}`));
-        });
-        const shifted = $.let(div.multiply(100.0).add(0.5));
-        const rounded_int = $.let(shifted.subtract(shifted.remainder(1.0)));
-        const rounded = $.let(rounded_int.divide(100.0));
-        $.return(negative.ifElse(() => Expr.str `-${rounded}${suffix}`, () => Expr.str `${rounded}${suffix}`));
-    }),
+    },
     /**
      * Formats a float as a percentage.
      *
@@ -541,24 +570,26 @@ export default {
      * compiled(-0.123, 2n);  // "-12.30%"
      * ```
      */
-    printPercentage: Expr.function([FloatType, IntegerType], StringType, ($, x, decimals) => {
-        // Check for NaN/Infinity
-        $.if(Expr.equal(x, NaN), $ => $.error("Cannot format NaN"));
-        $.if(Expr.equal(x, Infinity), $ => $.error("Cannot format Infinity"));
-        $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot format -Infinity"));
-        const percentage = $.let(x.multiply(100.0));
-        // Build multiplier
-        const remaining = $.let(decimals);
-        const multiplier = $.let(1.0);
-        $.while(Expr.greater(remaining, 0n), $ => {
-            $.assign(multiplier, multiplier.multiply(10.0));
-            $.assign(remaining, remaining.subtract(1n));
+    get printPercentage() {
+        return Expr.function([FloatType, IntegerType], StringType, ($, x, decimals) => {
+            // Check for NaN/Infinity
+            $.if(Expr.equal(x, NaN), $ => $.error("Cannot format NaN"));
+            $.if(Expr.equal(x, Infinity), $ => $.error("Cannot format Infinity"));
+            $.if(Expr.equal(x, -Infinity), $ => $.error("Cannot format -Infinity"));
+            const percentage = $.let(x.multiply(100.0));
+            // Build multiplier
+            const remaining = $.let(decimals);
+            const multiplier = $.let(1.0);
+            $.while(Expr.greater(remaining, 0n), $ => {
+                $.assign(multiplier, multiplier.multiply(10.0));
+                $.assign(remaining, remaining.subtract(1n));
+            });
+            const scaled = $.let(percentage.multiply(multiplier));
+            const shifted = $.let(Expr.greaterEqual(scaled, 0.0).ifElse(() => scaled.add(0.5), () => scaled.subtract(0.5)));
+            const rounded_int = $.let(shifted.subtract(shifted.remainder(1.0)));
+            const rounded = $.let(rounded_int.divide(multiplier));
+            $.return(Expr.str `${rounded}%`);
         });
-        const scaled = $.let(percentage.multiply(multiplier));
-        const shifted = $.let(Expr.greaterEqual(scaled, 0.0).ifElse(() => scaled.add(0.5), () => scaled.subtract(0.5)));
-        const rounded_int = $.let(shifted.subtract(shifted.remainder(1.0)));
-        const rounded = $.let(rounded_int.divide(multiplier));
-        $.return(Expr.str `${rounded}%`);
-    }),
-};
+    },
+});
 //# sourceMappingURL=float.js.map