@ball-lang/engine 1.3.6 → 1.3.8

package/dist/engine_setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine_setup.d.ts","sourceRoot":"","sources":["../src/engine_setup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,GAAG,CAAC;IAChB,gBAAgB,EAAE,GAAG,CAAC;IACtB,aAAa,EAAE,GAAG,CAAC;IACnB,WAAW,EAAE,GAAG,CAAC;IACjB,UAAU,CAAC,EAAE,GAAG,CAAC;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;CAClB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY;qBA8TzB,GAAG,2BAAuB,GAAG;qBA6E7B,GAAG,KAAG,GAAG;eAqCf,GAAG,KAAG,MAAM;;;;4BA8CZ,GAAG,GAAG,OAAO;0BACf,GAAG,GAAG,IAAI;qBACf,MAAM,SAAS,GAAG,WAAW,GAAG,GAAG,GAAG;;;yDAqIkB,GAAG,KAAG,IAAI;0CA0iBvB,IAAI;sCAgfR,IAAI;sCA0Bb,GAAG,KAAG,IAAI;uBA5nDzB,GAAG,KAAG,OAAO;0BAwmCV,GAAG,KAAG,GAAG;EA0jBvC"}
+{"version":3,"file":"engine_setup.d.ts","sourceRoot":"","sources":["../src/engine_setup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,GAAG,CAAC;IAChB,gBAAgB,EAAE,GAAG,CAAC;IACtB,aAAa,EAAE,GAAG,CAAC;IACnB,WAAW,EAAE,GAAG,CAAC;IACjB,UAAU,CAAC,EAAE,GAAG,CAAC;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;CAClB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY;qBAoUzB,GAAG,2BAAuB,GAAG;qBA6E7B,GAAG,KAAG,GAAG;eAqCf,GAAG,KAAG,MAAM;;;;4BA8CZ,GAAG,GAAG,OAAO;0BACf,GAAG,GAAG,IAAI;qBACf,MAAM,SAAS,GAAG,WAAW,GAAG,GAAG,GAAG;;;yDAkJkB,GAAG,KAAG,IAAI;0CA0iBvB,IAAI;sCAshBR,IAAI;sCA0Bb,GAAG,KAAG,IAAI;uBArrDzB,GAAG,KAAG,OAAO;0BA2nCV,GAAG,KAAG,GAAG;EAgmBvC"}

package/dist/engine_setup.js

@@ -223,6 +223,13 @@ export function createEngineSetup(mod) {
         return rem < 0 ? rem + Math.abs(r) : rem;
     }
     function _mathAbs(v) {
+        // `_coerceInt` unconditionally truncates through int64 coercion (needed
+        // for BigInt-magnitude int abs), which silently dropped double-ness for
+        // a BallDouble operand — e.g. `(2.5).abs()` returned `2` instead of
+        // `2.5` (#115). Route a BallDouble operand through double abs instead.
+        const BD = globalThis.BallDouble;
+        if (BD && v instanceof BD)
+            return new BD(Math.abs(v.value));
         const coerced = _coerceInt(v);
         if (typeof coerced === 'bigint') {
             return _int64Result(coerced < 0n ? -coerced : coerced);
@@ -601,6 +608,19 @@ export function createEngineSetup(mod) {
                     case 'ceil': return Math.ceil(self);
                     case 'compareTo': return self < arg0 ? -1 : self > arg0 ? 1 : 0;
                     case 'clamp': return Math.min(Math.max(self, arg0), arg1);
+                    case 'remainder': return self % Number(_coerceNum(arg0));
+                }
+            }
+            // A BallDouble-wrapped receiver (e.g. `double d = 2.5; d.remainder(2)`)
+            // falls through every case above (`typeof self !== 'number'`), and the
+            // compiled engine's own dispatch calls `self.remainder(...)` — a real
+            // method call that doesn't exist on the BallDouble class (unlike
+            // floor/ceil/round/abs, which work by accident via Math.* coercing
+            // through BallDouble.valueOf()) (#115). Handle it explicitly here.
+            {
+                const BD = globalThis.BallDouble;
+                if (BD && self instanceof BD && fn === 'remainder') {
+                    return new BD(self.value % Number(_coerceNum(arg0)));
                 }
             }
             if (typeof self === 'object' && self !== null && '__type__' in self) {
@@ -1530,7 +1550,17 @@ export function createEngineSetup(mod) {
             return op(l, r);
         };
         e._stdUnaryNum = function (input, op) {
-            return op(_coerceNum(e._extractUnaryArg(input)));
+            // Preserve BallDouble-ness through negate (#67): a whole-number
+            // double like `-7.0` must not collapse to a bare JS integer. Mirrors
+            // the _stdBinary patch above. bitwise_not (the only other consumer)
+            // always operates on int, so it never sees a BallDouble operand here.
+            const value = e._extractUnaryArg(input);
+            const BD = globalThis.BallDouble;
+            const vBD = BD && value instanceof BD;
+            const result = op(_coerceNum(value));
+            if (vBD && typeof result === 'number')
+                return new BD(result);
+            return result;
         };
         e._stdBinaryComp = function (input, op) {
             const rec = e._extractBinaryArgs(input);
@@ -1561,6 +1591,24 @@ export function createEngineSetup(mod) {
             }
             return result;
         };
+        // `remainder` is the one num instance method the compiled engine's own
+        // `_dispatchBuiltinInstanceMethod` calls as a literal Dart method
+        // (`self.remainder(...)`) rather than routing through a Math.*-backed
+        // std function (floor/ceil/round/abs/truncate all get encoder-routed to
+        // math_floor/math_ceil/etc, which is why they survive a BallDouble
+        // receiver via valueOf() coercion). A BallDouble-wrapped receiver has no
+        // `.remainder` method, so it throws (#115). Intercept just that case.
+        const origDispatchBuiltinInstanceMethod = e._dispatchBuiltinInstanceMethod.bind(e);
+        e._dispatchBuiltinInstanceMethod = async function (self, method, input) {
+            const BD = globalThis.BallDouble;
+            if (BD && self instanceof BD && method === 'remainder') {
+                const rec = e._cfAsMap(input) ?? {};
+                const rawArg = rec['arg0'] ?? rec['value'];
+                const other = (BD && rawArg instanceof BD) ? rawArg.value : _coerceNum(rawArg);
+                return new BD(self.value % Number(other));
+            }
+            return origDispatchBuiltinInstanceMethod(self, method, input);
+        };
         const origPatternKind = e._patternKind?.bind(e);
         e._patternKind = function (pattern) {
             const explicit = pattern?.['__pattern_kind__'];
@@ -1965,7 +2013,18 @@ export function createEngineSetup(mod) {
                 const rec = e._extractBinaryArgs(i);
                 return _int64Modulo(rec[0], rec[1]);
             });
-            handler.register('negate', (i) => _int64Negate(e._extractUnaryArg(i)));
+            handler.register('negate', (i) => {
+                // `_int64Negate` unconditionally coerces through `_coerceInt` (it's
+                // the int64-safe path for `bigint`-magnitude values), which silently
+                // truncated a double operand to an int — losing double-ness for
+                // e.g. `-7.0` (#67). Route a BallDouble operand through double
+                // negation instead; only a genuine int reaches `_int64Negate`.
+                const value = e._extractUnaryArg(i);
+                const BD = globalThis.BallDouble;
+                if (BD && value instanceof BD)
+                    return new BD(-value.value);
+                return _int64Negate(value);
+            });
             handler.register('bitwise_and', (i) => e._stdBinaryInt(i, (a, b) => _int64Binary((l, r) => l & r, a, b)));
             handler.register('bitwise_or', (i) => e._stdBinaryInt(i, (a, b) => _int64Binary((l, r) => l | r, a, b)));
             handler.register('bitwise_xor', (i) => e._stdBinaryInt(i, (a, b) => _int64Binary((l, r) => l ^ r, a, b)));