@elaraai/east 1.0.84 → 1.0.85

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

@@ -4,8 +4,9 @@
  */
 import { IntegerType, StringType } from "../../types.js";
 import { Expr } from "../expr.js";
+import { lazyLibrary } from "./lazy.js";
 /** Standard library functions for integers */
-export default {
+export default lazyLibrary({
     /**
      * Formats an integer with comma separators for thousands.
      *
@@ -23,30 +24,32 @@ export default {
      * compiled(-5432n);      // "-5,432"
      * ```
      */
-    printCommaSeperated: Expr.function([IntegerType], StringType, ($, x) => {
-        const y = $.let(x);
-        const negative = $.let(false);
-        $.if(Expr.less(y, 0n), $ => {
-            $.if(Expr.equal(y, -9223372036854775808n), $ => $.return("-9,223,372,036,854,775,808")); // cannot negate -2^63 as an i64
-            $.assign(negative, true);
-            $.assign(y, y.negate());
-        });
-        const ret = $.let("");
-        $.while(Expr.greater(y, 999n), $ => {
-            const z = $.let(y.remainder(1000n));
-            $.if(Expr.less(z, 10n), $ => {
-                $.assign(ret, Expr.str `,00${z}${ret}`);
-            }).else($ => {
-                $.if(Expr.less(z, 100n), $ => {
-                    $.assign(ret, Expr.str `,0${z}${ret}`);
+    get printCommaSeperated() {
+        return Expr.function([IntegerType], StringType, ($, x) => {
+            const y = $.let(x);
+            const negative = $.let(false);
+            $.if(Expr.less(y, 0n), $ => {
+                $.if(Expr.equal(y, -9223372036854775808n), $ => $.return("-9,223,372,036,854,775,808")); // cannot negate -2^63 as an i64
+                $.assign(negative, true);
+                $.assign(y, y.negate());
+            });
+            const ret = $.let("");
+            $.while(Expr.greater(y, 999n), $ => {
+                const z = $.let(y.remainder(1000n));
+                $.if(Expr.less(z, 10n), $ => {
+                    $.assign(ret, Expr.str `,00${z}${ret}`);
                 }).else($ => {
-                    $.assign(ret, Expr.str `,${z}${ret}`);
+                    $.if(Expr.less(z, 100n), $ => {
+                        $.assign(ret, Expr.str `,0${z}${ret}`);
+                    }).else($ => {
+                        $.assign(ret, Expr.str `,${z}${ret}`);
+                    });
                 });
+                $.assign(y, y.divide(1000n));
             });
-            $.assign(y, y.divide(1000n));
+            $.if(negative, $ => $.return(Expr.str `-${y}${ret}`)).else($ => $.return(Expr.str `${y}${ret}`));
         });
-        $.if(negative, $ => $.return(Expr.str `-${y}${ret}`)).else($ => $.return(Expr.str `${y}${ret}`));
-    }),
+    },
     /**
      * Formats a float as currency with comma separators and 2 decimal places.
      *
@@ -65,35 +68,37 @@ export default {
      * compiled(1000000n);    // "$1,000,000"
      * ```
      */
-    printCurrency: Expr.function([IntegerType], StringType, ($, x) => {
-        // Check for NaN/Infinity
-        const negative = $.let(Expr.less(x, 0n));
-        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));
-        // 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([IntegerType], StringType, ($, x) => {
+            // Check for NaN/Infinity
+            const negative = $.let(Expr.less(x, 0n));
+            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));
+            // 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 result = $.let(Expr.str `${dollars_str}`);
+            $.return(negative.ifElse(() => Expr.str `-$${result}`, () => Expr.str `$${result}`));
         });
-        const dollars_str = $.let(Expr.str `${dollars_with_commas}${comma_ret}`);
-        const result = $.let(Expr.str `${dollars_str}`);
-        $.return(negative.ifElse(() => Expr.str `-$${result}`, () => Expr.str `$${result}`));
-    }),
+    },
     /**
      * Formats an integer in compact form with business unit suffixes.
      *
@@ -115,39 +120,41 @@ export default {
      * compiled(500n);         // "500"
      * ```
      */
-    printCompact: Expr.function([IntegerType], StringType, ($, x) => {
-        const y = $.let(x);
-        const negative = $.let(false);
-        $.if(Expr.less(y, 0n), $ => {
-            $.if(Expr.equal(y, -9223372036854775808n), $ => $.return("-9.22Qi")); // cannot negate -2^63 as an i64
-            $.assign(negative, true);
-            $.assign(y, y.negate());
-        });
-        $.if(Expr.less(y, 1000n), $ => $.return(negative.ifElse(() => Expr.str `-${y}`, () => Expr.str `${y}`)));
-        const scale = $.let(1n);
-        $.while(Expr.greaterEqual(y, 1000000n), $ => {
-            $.assign(y, y.divide(1000n));
-            $.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"))))));
-        $.if(Expr.greaterEqual(y, 100000n), $ => {
-            $.if(negative, $ => {
-                $.return(Expr.str `-${y.divide(1000n)}${suffix}`);
+    get printCompact() {
+        return Expr.function([IntegerType], StringType, ($, x) => {
+            const y = $.let(x);
+            const negative = $.let(false);
+            $.if(Expr.less(y, 0n), $ => {
+                $.if(Expr.equal(y, -9223372036854775808n), $ => $.return("-9.22Qi")); // cannot negate -2^63 as an i64
+                $.assign(negative, true);
+                $.assign(y, y.negate());
+            });
+            $.if(Expr.less(y, 1000n), $ => $.return(negative.ifElse(() => Expr.str `-${y}`, () => Expr.str `${y}`)));
+            const scale = $.let(1n);
+            $.while(Expr.greaterEqual(y, 1000000n), $ => {
+                $.assign(y, y.divide(1000n));
+                $.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"))))));
+            $.if(Expr.greaterEqual(y, 100000n), $ => {
+                $.if(negative, $ => {
+                    $.return(Expr.str `-${y.divide(1000n)}${suffix}`);
+                }).else($ => {
+                    $.return(Expr.str `${y.divide(1000n)}${suffix}`);
+                });
+            });
+            $.if(Expr.greaterEqual(y, 10000n), $ => {
+                const part = $.let(y.divide(100n).remainder(10n));
+                $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.${part}${suffix}`));
+            });
+            const part = $.let(y.divide(10n).remainder(100n));
+            $.if(Expr.greaterEqual(part, 10n), $ => {
+                $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.${part}${suffix}`));
             }).else($ => {
-                $.return(Expr.str `${y.divide(1000n)}${suffix}`);
+                $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.0${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.0${part}${suffix}`));
             });
         });
-        $.if(Expr.greaterEqual(y, 10000n), $ => {
-            const part = $.let(y.divide(100n).remainder(10n));
-            $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.${part}${suffix}`));
-        });
-        const part = $.let(y.divide(10n).remainder(100n));
-        $.if(Expr.greaterEqual(part, 10n), $ => {
-            $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.${part}${suffix}`));
-        }).else($ => {
-            $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.0${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.0${part}${suffix}`));
-        });
-    }),
+    },
     /**
      * Formats an integer in compact form with SI (International System) unit suffixes.
      *
@@ -169,33 +176,35 @@ export default {
      * compiled(3140000000n);  // "3.14G"
      * ```
      */
-    printCompactSI: Expr.function([IntegerType], StringType, ($, x) => {
-        const y = $.let(x);
-        const negative = $.let(false);
-        $.if(Expr.less(y, 0n), $ => {
-            $.if(Expr.equal(y, -9223372036854775808n), $ => $.return("-9.22E")); // cannot negate -2^63 as an i64
-            $.assign(negative, true);
-            $.assign(y, y.negate());
-        });
-        $.if(Expr.less(y, 1000n), $ => $.return(negative.ifElse(() => Expr.str `-${y}`, () => Expr.str `${y}`)));
-        const scale = $.let(1n);
-        $.while(Expr.greaterEqual(y, 1000000n), $ => {
-            $.assign(y, y.divide(1000n));
-            $.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(() => "G", () => Expr.equal(scale, 4n).ifElse(() => "T", () => Expr.equal(scale, 5n).ifElse(() => "P", () => "E"))))));
-        $.if(Expr.greaterEqual(y, 100000n), $ => $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}${suffix}`)));
-        $.if(Expr.greaterEqual(y, 10000n), $ => {
-            const part = $.let(y.divide(100n).remainder(10n));
-            $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.${part}${suffix}`));
-        });
-        const part = $.let(y.divide(10n).remainder(100n));
-        $.if(Expr.greaterEqual(part, 10n), $ => {
-            $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.${part}${suffix}`));
-        }).else($ => {
-            $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.0${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.0${part}${suffix}`));
+    get printCompactSI() {
+        return Expr.function([IntegerType], StringType, ($, x) => {
+            const y = $.let(x);
+            const negative = $.let(false);
+            $.if(Expr.less(y, 0n), $ => {
+                $.if(Expr.equal(y, -9223372036854775808n), $ => $.return("-9.22E")); // cannot negate -2^63 as an i64
+                $.assign(negative, true);
+                $.assign(y, y.negate());
+            });
+            $.if(Expr.less(y, 1000n), $ => $.return(negative.ifElse(() => Expr.str `-${y}`, () => Expr.str `${y}`)));
+            const scale = $.let(1n);
+            $.while(Expr.greaterEqual(y, 1000000n), $ => {
+                $.assign(y, y.divide(1000n));
+                $.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(() => "G", () => Expr.equal(scale, 4n).ifElse(() => "T", () => Expr.equal(scale, 5n).ifElse(() => "P", () => "E"))))));
+            $.if(Expr.greaterEqual(y, 100000n), $ => $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}${suffix}`)));
+            $.if(Expr.greaterEqual(y, 10000n), $ => {
+                const part = $.let(y.divide(100n).remainder(10n));
+                $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.${part}${suffix}`));
+            });
+            const part = $.let(y.divide(10n).remainder(100n));
+            $.if(Expr.greaterEqual(part, 10n), $ => {
+                $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.${part}${suffix}`));
+            }).else($ => {
+                $.if(negative, $ => $.return(Expr.str `-${y.divide(1000n)}.0${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1000n)}.0${part}${suffix}`));
+            });
         });
-    }),
+    },
     /**
      * Formats an integer in compact form with binary computing unit suffixes.
      *
@@ -217,33 +226,35 @@ export default {
      * compiled(3221225472n); // "3Gi"    (3 GiB)
      * ```
      */
-    printCompactComputing: Expr.function([IntegerType], StringType, ($, x) => {
-        const y = $.let(x);
-        const negative = $.let(false);
-        $.if(Expr.less(y, 0n), $ => {
-            $.if(Expr.equal(y, -9223372036854775808n), $ => $.return("-7.99Ei")); // cannot negate -2^63 as an i64
-            $.assign(negative, true);
-            $.assign(y, y.negate());
-        });
-        $.if(Expr.less(y, 1000n), $ => $.return(negative.ifElse(() => Expr.str `-${y}`, () => Expr.str `${y}`)));
-        const scale = $.let(1n);
-        $.while(Expr.greaterEqual(y, 1048576n), $ => {
-            $.assign(y, y.divide(1024n));
-            $.assign(scale, scale.add(1n));
-        });
-        const suffix = $.let(Expr.equal(scale, 1n).ifElse(() => "ki", () => Expr.equal(scale, 2n).ifElse(() => "Mi", () => Expr.equal(scale, 3n).ifElse(() => "Gi", () => Expr.equal(scale, 4n).ifElse(() => "Ti", () => Expr.equal(scale, 5n).ifElse(() => "Pi", () => "Ei"))))));
-        $.if(Expr.greaterEqual(y, 102400n), $ => $.if(negative, $ => $.return(Expr.str `-${y.divide(1024n)}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1024n)}${suffix}`)));
-        $.if(Expr.greaterEqual(y, 10240n), $ => {
-            const part = $.let(y.multiply(10n).divide(1024n).remainder(10n));
-            $.if(negative, $ => $.return(Expr.str `-${y.divide(1024n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1024n)}.${part}${suffix}`));
-        });
-        const part = $.let(y.multiply(100n).divide(1024n).remainder(100n));
-        $.if(Expr.greaterEqual(part, 10n), $ => {
-            $.if(negative, $ => $.return(Expr.str `-${y.divide(1024n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1024n)}.${part}${suffix}`));
-        }).else($ => {
-            $.if(negative, $ => $.return(Expr.str `-${y.divide(1024n)}.0${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1024n)}.0${part}${suffix}`));
+    get printCompactComputing() {
+        return Expr.function([IntegerType], StringType, ($, x) => {
+            const y = $.let(x);
+            const negative = $.let(false);
+            $.if(Expr.less(y, 0n), $ => {
+                $.if(Expr.equal(y, -9223372036854775808n), $ => $.return("-7.99Ei")); // cannot negate -2^63 as an i64
+                $.assign(negative, true);
+                $.assign(y, y.negate());
+            });
+            $.if(Expr.less(y, 1000n), $ => $.return(negative.ifElse(() => Expr.str `-${y}`, () => Expr.str `${y}`)));
+            const scale = $.let(1n);
+            $.while(Expr.greaterEqual(y, 1048576n), $ => {
+                $.assign(y, y.divide(1024n));
+                $.assign(scale, scale.add(1n));
+            });
+            const suffix = $.let(Expr.equal(scale, 1n).ifElse(() => "ki", () => Expr.equal(scale, 2n).ifElse(() => "Mi", () => Expr.equal(scale, 3n).ifElse(() => "Gi", () => Expr.equal(scale, 4n).ifElse(() => "Ti", () => Expr.equal(scale, 5n).ifElse(() => "Pi", () => "Ei"))))));
+            $.if(Expr.greaterEqual(y, 102400n), $ => $.if(negative, $ => $.return(Expr.str `-${y.divide(1024n)}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1024n)}${suffix}`)));
+            $.if(Expr.greaterEqual(y, 10240n), $ => {
+                const part = $.let(y.multiply(10n).divide(1024n).remainder(10n));
+                $.if(negative, $ => $.return(Expr.str `-${y.divide(1024n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1024n)}.${part}${suffix}`));
+            });
+            const part = $.let(y.multiply(100n).divide(1024n).remainder(100n));
+            $.if(Expr.greaterEqual(part, 10n), $ => {
+                $.if(negative, $ => $.return(Expr.str `-${y.divide(1024n)}.${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1024n)}.${part}${suffix}`));
+            }).else($ => {
+                $.if(negative, $ => $.return(Expr.str `-${y.divide(1024n)}.0${part}${suffix}`)).else($ => $.return(Expr.str `${y.divide(1024n)}.0${part}${suffix}`));
+            });
         });
-    }),
+    },
     /**
      * Formats an integer as an ordinal number.
      *
@@ -264,20 +275,22 @@ export default {
      * compiled(112n);  // "112th"
      * ```
      */
-    printOrdinal: Expr.function([IntegerType], StringType, ($, x) => {
-        const abs_x = $.let(x.abs());
-        const last_digit = $.let(abs_x.remainder(10n));
-        const last_two_digits = $.let(abs_x.remainder(100n));
-        // Special cases for 11th, 12th, 13th
-        $.if(Expr.greaterEqual(last_two_digits, 11n).bitAnd(Expr.lessEqual(last_two_digits, 13n)), $ => {
-            $.return(Expr.str `${x}th`);
-        });
-        $.if(Expr.equal(last_digit, 1n), $ => $.return(Expr.str `${x}st`)).else($ => {
-            $.if(Expr.equal(last_digit, 2n), $ => $.return(Expr.str `${x}nd`)).else($ => {
-                $.if(Expr.equal(last_digit, 3n), $ => $.return(Expr.str `${x}rd`)).else($ => $.return(Expr.str `${x}th`));
+    get printOrdinal() {
+        return Expr.function([IntegerType], StringType, ($, x) => {
+            const abs_x = $.let(x.abs());
+            const last_digit = $.let(abs_x.remainder(10n));
+            const last_two_digits = $.let(abs_x.remainder(100n));
+            // Special cases for 11th, 12th, 13th
+            $.if(Expr.greaterEqual(last_two_digits, 11n).bitAnd(Expr.lessEqual(last_two_digits, 13n)), $ => {
+                $.return(Expr.str `${x}th`);
+            });
+            $.if(Expr.equal(last_digit, 1n), $ => $.return(Expr.str `${x}st`)).else($ => {
+                $.if(Expr.equal(last_digit, 2n), $ => $.return(Expr.str `${x}nd`)).else($ => {
+                    $.if(Expr.equal(last_digit, 3n), $ => $.return(Expr.str `${x}rd`)).else($ => $.return(Expr.str `${x}th`));
+                });
             });
         });
-    }),
+    },
     /**
      * Counts the number of decimal digits in an integer (excluding the sign).
      *
@@ -296,10 +309,12 @@ export default {
      * compiled(1000000n); // 7n
      * ```
      */
-    digitCount: Expr.function([IntegerType], IntegerType, ($, x) => {
-        $.if(Expr.equal(x, 0n), $ => $.return(1n));
-        $.return(x.abs().log(10n).add(1n));
-    }),
+    get digitCount() {
+        return Expr.function([IntegerType], IntegerType, ($, x) => {
+            $.if(Expr.equal(x, 0n), $ => $.return(1n));
+            $.return(x.abs().log(10n).add(1n));
+        });
+    },
     /**
      * Rounds an integer to the nearest multiple of a step value.
      *
@@ -318,22 +333,24 @@ export default {
      * compiled(-17n, 5n);  // -15n
      * ```
      */
-    roundNearest: Expr.function([IntegerType, IntegerType], IntegerType, ($, x, step) => {
-        // For step = 0, return original value
-        $.if(Expr.equal(step, 0n), $ => $.return(x));
-        const abs_step = $.let(step.abs());
-        const abs_x = $.let(x.abs());
-        const remainder = $.let(abs_x.remainder(abs_step));
-        const half_step = $.let(abs_step.divide(2n));
-        $.if(Expr.equal(remainder, 0n), $ => $.return(x) // Already a multiple
-        ).else($ => {
-            const rounded_abs = $.let(Expr.less(remainder, half_step)
-                .ifElse(() => abs_x.subtract(remainder), // Round down
-            () => abs_x.add(abs_step.subtract(remainder)) // Round up
-            ));
-            $.if(Expr.greaterEqual(x, 0n), $ => $.return(rounded_abs)).else($ => $.return(rounded_abs.negate()));
+    get roundNearest() {
+        return Expr.function([IntegerType, IntegerType], IntegerType, ($, x, step) => {
+            // For step = 0, return original value
+            $.if(Expr.equal(step, 0n), $ => $.return(x));
+            const abs_step = $.let(step.abs());
+            const abs_x = $.let(x.abs());
+            const remainder = $.let(abs_x.remainder(abs_step));
+            const half_step = $.let(abs_step.divide(2n));
+            $.if(Expr.equal(remainder, 0n), $ => $.return(x) // Already a multiple
+            ).else($ => {
+                const rounded_abs = $.let(Expr.less(remainder, half_step)
+                    .ifElse(() => abs_x.subtract(remainder), // Round down
+                () => abs_x.add(abs_step.subtract(remainder)) // Round up
+                ));
+                $.if(Expr.greaterEqual(x, 0n), $ => $.return(rounded_abs)).else($ => $.return(rounded_abs.negate()));
+            });
         });
-    }),
+    },
     /**
      * Rounds an integer up to the next multiple of a step value (ceiling).
      *
@@ -352,18 +369,20 @@ export default {
      * compiled(-17n, 5n);  // -15n (towards zero for negatives)
      * ```
      */
-    roundUp: Expr.function([IntegerType, IntegerType], IntegerType, ($, x, step) => {
-        // For step = 0, return original value
-        $.if(Expr.equal(step, 0n), $ => $.return(x));
-        const abs_step = $.let(step.abs());
-        const remainder = $.let(x.remainder(abs_step));
-        $.if(Expr.equal(remainder, 0n), $ => $.return(x) // Already a multiple
-        ).else($ => {
-            $.if(Expr.greaterEqual(x, 0n), $ => $.return(x.add(abs_step.subtract(remainder))) // Positive: round up
-            ).else($ => $.return(x.subtract(remainder)) // Negative: round towards zero
-            );
+    get roundUp() {
+        return Expr.function([IntegerType, IntegerType], IntegerType, ($, x, step) => {
+            // For step = 0, return original value
+            $.if(Expr.equal(step, 0n), $ => $.return(x));
+            const abs_step = $.let(step.abs());
+            const remainder = $.let(x.remainder(abs_step));
+            $.if(Expr.equal(remainder, 0n), $ => $.return(x) // Already a multiple
+            ).else($ => {
+                $.if(Expr.greaterEqual(x, 0n), $ => $.return(x.add(abs_step.subtract(remainder))) // Positive: round up
+                ).else($ => $.return(x.subtract(remainder)) // Negative: round towards zero
+                );
+            });
         });
-    }),
+    },
     /**
      * Rounds an integer down to the previous multiple of a step value (floor).
      *
@@ -382,18 +401,20 @@ export default {
      * compiled(-17n, 5n);  // -20n (away from zero for negatives)
      * ```
      */
-    roundDown: Expr.function([IntegerType, IntegerType], IntegerType, ($, x, step) => {
-        // For step = 0, return original value
-        $.if(Expr.equal(step, 0n), $ => $.return(x));
-        const abs_step = $.let(step.abs());
-        const remainder = $.let(x.remainder(abs_step));
-        $.if(Expr.equal(remainder, 0n), $ => $.return(x) // Already a multiple
-        ).else($ => {
-            $.if(Expr.greaterEqual(x, 0n), $ => $.return(x.subtract(remainder)) // Positive: round down
-            ).else($ => $.return(x.subtract(abs_step.add(remainder))) // Negative: round away from zero
-            );
+    get roundDown() {
+        return Expr.function([IntegerType, IntegerType], IntegerType, ($, x, step) => {
+            // For step = 0, return original value
+            $.if(Expr.equal(step, 0n), $ => $.return(x));
+            const abs_step = $.let(step.abs());
+            const remainder = $.let(x.remainder(abs_step));
+            $.if(Expr.equal(remainder, 0n), $ => $.return(x) // Already a multiple
+            ).else($ => {
+                $.if(Expr.greaterEqual(x, 0n), $ => $.return(x.subtract(remainder)) // Positive: round down
+                ).else($ => $.return(x.subtract(abs_step.add(remainder))) // Negative: round away from zero
+                );
+            });
         });
-    }),
+    },
     /**
      * Rounds an integer towards zero to the nearest multiple of a step value (truncate).
      *
@@ -412,15 +433,17 @@ export default {
      * compiled(3n, 5n);    // 0n
      * ```
      */
-    roundTruncate: Expr.function([IntegerType, IntegerType], IntegerType, ($, x, step) => {
-        // For step = 0, return original value
-        $.if(Expr.equal(step, 0n), $ => $.return(x));
-        const abs_step = $.let(step.abs());
-        const remainder = $.let(x.remainder(abs_step));
-        $.if(Expr.equal(remainder, 0n), $ => $.return(x) // Already a multiple
-        ).else($ => $.return(x.subtract(remainder)) // Always subtract remainder (towards zero)
-        );
-    }),
+    get roundTruncate() {
+        return Expr.function([IntegerType, IntegerType], IntegerType, ($, x, step) => {
+            // For step = 0, return original value
+            $.if(Expr.equal(step, 0n), $ => $.return(x));
+            const abs_step = $.let(step.abs());
+            const remainder = $.let(x.remainder(abs_step));
+            $.if(Expr.equal(remainder, 0n), $ => $.return(x) // Already a multiple
+            ).else($ => $.return(x.subtract(remainder)) // Always subtract remainder (towards zero)
+            );
+        });
+    },
     /**
      * Formats an integer as a percentage.
      *
@@ -438,8 +461,10 @@ export default {
      * compiled(-25n);  // "-25%"
      * ```
      */
-    printPercentage: Expr.function([IntegerType], StringType, ($, x) => {
-        $.return(Expr.str `${x}%`);
-    }),
-};
+    get printPercentage() {
+        return Expr.function([IntegerType], StringType, ($, x) => {
+            $.return(Expr.str `${x}%`);
+        });
+    },
+});
 //# sourceMappingURL=integer.js.map