@ball-lang/engine 1.68.6 → 1.69.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ball-lang/engine",
-  "version": "1.68.6",
+  "version": "1.69.0",
   "description": "Ball language engine — interprets Ball programs in TypeScript/JavaScript. Runs in Node.js and browsers.",
   "type": "module",
   "main": "dist/index.js",

package/src/compiled_engine.ts

@@ -6456,7 +6456,35 @@ export class BallEngine {
           return self.includes(arg0);
         }
         else if ((__sw === 'indexOf')) {
-          return self.indexOf(arg0);
+          let indexFrom = __ball_index(args, 'arg1');
+          if (__ball_eq(indexFrom, null)) {
+            return self.indexOf(arg0);
+          }
+          let scan = this._toInt(indexFrom);
+          if (__ball_lt(scan, 0)) {
+            scan = 0;
+          }
+          while (__ball_lt(scan, self.length)) {
+            if (__ball_eq(__ball_index(self, scan), arg0)) {
+              return scan;
+            }
+            (scan++);
+          }
+          return __ball_negate(1);
+        }
+        else if ((__sw === 'lastIndexOf')) {
+          let lastFrom = __ball_index(args, 'arg1');
+          let lastScan = (__ball_eq(lastFrom, null) ? __ball_sub(self.length, 1) : this._toInt(lastFrom));
+          if (__ball_ge(lastScan, self.length)) {
+            lastScan = __ball_sub(self.length, 1);
+          }
+          while (__ball_ge(lastScan, 0)) {
+            if (__ball_eq(__ball_index(self, lastScan), arg0)) {
+              return lastScan;
+            }
+            (lastScan--);
+          }
+          return __ball_negate(1);
         }
         else if ((__sw === 'join')) {
           let joinParts = [];
@@ -6806,7 +6834,19 @@ export class BallEngine {
           return self.substring(this._toInt(arg0), (!__ball_eq(end, null) ? this._toInt(end) : null));
         }
         else if ((__sw === 'indexOf')) {
-          return self.indexOf(__ball_to_string(arg0));
+          let strFrom = __ball_index(args, 'arg1');
+          if (__ball_eq(strFrom, null)) {
+            return self.indexOf(__ball_to_string(arg0));
+          }
+          let strScan = this._toInt(strFrom);
+          if (__ball_lt(strScan, 0)) {
+            strScan = 0;
+          }
+          if (__ball_gt(strScan, self.length)) {
+            return __ball_negate(1);
+          }
+          let strHit = self.substring(strScan).indexOf(__ball_to_string(arg0));
+          return (__ball_lt(strHit, 0) ? __ball_negate(1) : __ball_add(strHit, strScan));
         }
         else if ((__sw === 'split')) {
           return self.split(__ball_to_string(arg0));
@@ -6824,7 +6864,51 @@ export class BallEngine {
           return self.split(__ball_to_string(arg0)).join(__ball_to_string((__ball_index(args, 'arg1') ?? '')));
         }
         else if ((__sw === 'startsWith')) {
-          return self.startsWith(__ball_to_string(arg0));
+          let swFrom = __ball_index(args, 'arg1');
+          if (__ball_eq(swFrom, null)) {
+            return self.startsWith(__ball_to_string(arg0));
+          }
+          let swAt = this._toInt(swFrom);
+          if (__ball_lt(swAt, 0)) {
+            swAt = 0;
+          }
+          if (__ball_gt(swAt, self.length)) {
+            return false;
+          }
+          return self.substring(swAt).startsWith(__ball_to_string(arg0));
+        }
+        else if ((__sw === 'lastIndexOf')) {
+          let liNeedle = __ball_to_string(arg0);
+          let liStart = __ball_index(args, 'arg1');
+          if (__ball_eq(liStart, null)) {
+            return self.lastIndexOf(liNeedle);
+          }
+          let liAt = this._toInt(liStart);
+          if (__ball_lt(liAt, 0)) {
+            return __ball_negate(1);
+          }
+          let liEnd = __ball_add(liAt, liNeedle.length);
+          if (__ball_gt(liEnd, self.length)) {
+            liEnd = self.length;
+          }
+          return self.substring(0, liEnd).lastIndexOf(liNeedle);
+        }
+        else if ((__sw === 'replaceFirst')) {
+          let rfTo = __ball_to_string((__ball_index(args, 'arg1') ?? ''));
+          let rfStart = __ball_index(args, 'arg2');
+          if (__ball_eq(rfStart, null)) {
+            return self.replace(__ball_to_string(arg0), rfTo);
+          }
+          let rfAt = this._toInt(rfStart);
+          if (__ball_lt(rfAt, 0)) {
+            rfAt = 0;
+          }
+          if (__ball_gt(rfAt, self.length)) {
+            return self;
+          }
+          let rfHead = self.substring(0, rfAt);
+          let rfTail = self.substring(rfAt).replace(__ball_to_string(arg0), rfTo);
+          return __ball_add(rfHead, rfTail);
         }
         else if ((__sw === 'endsWith')) {
           return self.endsWith(__ball_to_string(arg0));
@@ -7964,23 +8048,22 @@ export class BallEngine {
         let m = this._stdAsMap(i);
         let items = this._ballSetItems(__ball_index(m, 'set'));
         let value = __ball_index(m, 'value');
-        if (!items.includes(value)) {
-          this._trackMemoryAllocation(_ballPointerBytes);
-          return this._ballSetOf([items, value]);
+        if (items.includes(value)) {
+          return false;
         }
-        return this._ballSetOf(items);
+        this._trackMemoryAllocation(_ballPointerBytes);
+        items = (items.push(value), items);
+        return true;
       }), ['set_remove']: ((i) => {
         const input = i;
         let m = this._stdAsMap(i);
         let items = this._ballSetItems(__ball_index(m, 'set'));
-        let value = __ball_index(m, 'value');
-        let kept = [];
-        for (const e of items) {
-          if (!__ball_eq(e, value)) {
-            kept = (kept.push(e), kept);
-          }
+        let index = items.indexOf(__ball_index(m, 'value'));
+        if (__ball_lt(index, 0)) {
+          return false;
         }
-        return this._ballSetOf(kept);
+        items.splice(index, 1)[0];
+        return true;
       }), ['set_contains']: ((i) => {
         const input = i;
         let m = this._stdAsMap(i);

package/src/engine_setup.ts

@@ -949,7 +949,13 @@ export function createEngineSetup(mod: EngineModule) {
     _r('set_length', (i: any) => { const m = _m(i); const s = m['set'] ?? m['collection'] ?? new Set(); return s instanceof Set ? s.size : (Array.isArray(s) ? new Set(s).size : 0); });
     _r('set_from', (i: any) => { const m = _m(i); const l = m['list'] ?? m['collection'] ?? m['iterable'] ?? []; return new Set(Array.isArray(l) ? l : []); });
     _r('set_create', (i: any) => { const m = _m(i); return new Set(Array.isArray(m['elements'] ?? m['values'] ?? []) ? (m['elements'] ?? m['values'] ?? []) : []); });
-    _r('set_add', (i: any) => { const m = _m(i); const s = m['set'] ?? m['collection']; const v = m['value'] ?? m['element']; if (s instanceof Set) { s.add(v); return true; } return false; });
+    // `true` ONLY on a fresh insert (issue #545). The old unconditional `true`
+    // made `set_add` on an element already present answer differently here than
+    // on every other engine — Dart's `Set.add` reports whether the element was
+    // newly inserted, and that is the one portable contract (conformance
+    // fixture 459_set_add_remove_bool). `set_remove`'s `Set.delete` already
+    // reports presence correctly.
+    _r('set_add', (i: any) => { const m = _m(i); const s = m['set'] ?? m['collection']; const v = m['value'] ?? m['element']; if (s instanceof Set) { if (s.has(v)) return false; s.add(v); return true; } return false; });
     _r('set_remove', (i: any) => { const m = _m(i); const s = m['set'] ?? m['collection']; const v = m['value'] ?? m['element']; return s instanceof Set ? s.delete(v) : false; });
     _r('set_add_all', (i: any) => { const m = _m(i); const s = m['set'] ?? m['collection']; const other = m['other'] ?? m['elements'] ?? []; if (s instanceof Set) { const items = Array.isArray(other) ? other : (other instanceof Set ? [...other] : []); for (const item of items) s.add(item); } return null; });
     _r('union', (i: any) => { const m = _m(i); const self = m['self'] ?? m['set'] ?? new Set(); const other = m['arg0'] ?? m['other'] ?? new Set(); const sA = self instanceof Set ? self : new Set(Array.isArray(self) ? self : []); const sB = other instanceof Set ? other : new Set(Array.isArray(other) ? other : []); return new Set([...sA, ...sB]); });