toilscript 0.1.19 → 0.1.21

package/dist/web.js

@@ -1,8 +1,8 @@
-var ASSEMBLYSCRIPT_VERSION = "0.1.19";
+var ASSEMBLYSCRIPT_VERSION = "0.1.21";
   var ASSEMBLYSCRIPT_IMPORTMAP = {
   "imports": {
-    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.19/dist/toilscript.js",
-    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.19/dist/cli.js",
+    "toilscript": "https://cdn.jsdelivr.net/npm/toilscript@0.1.21/dist/toilscript.js",
+    "toilscript/cli": "https://cdn.jsdelivr.net/npm/toilscript@0.1.21/dist/cli.js",
     "binaryen": "https://cdn.jsdelivr.net/npm/binaryen@129.0.0-nightly.20260428/index.js",
     "long": "https://cdn.jsdelivr.net/npm/long@5.3.2/index.js"
   }

package/package.json

@@ -8,7 +8,7 @@
     "toilscript",
     "wasm"
   ],
-  "version": "0.1.19",
+  "version": "0.1.21",
   "author": "Daniel Wirtz <dcode+assemblyscript@dcode.io>",
   "license": "Apache-2.0",
   "homepage": "https://github.com/dacely-cloud/toilscript",

package/std/assembly/bignum/integer/i128.ts

@@ -355,6 +355,16 @@ export class i128 {
     return new i128(sum, hi2);
   }
 
+  /**
+   * Decimal (or `radix`) string. Sign + unsigned magnitude: negate (two's complement)
+   * and reinterpret as u128, which is layout-identical. i128.Min survives because
+   * neg(Min) == Min and its bit pattern reinterpreted unsigned is exactly 2^127.
+   */
+  toString(radix: i32 = 10): string {
+    if (!this.isNeg()) return changetype<u128>(this).toString(radix);
+    return '-' + changetype<u128>(this.neg()).toString(radix);
+  }
+
   /**
    * Convert to a normal array of bytes (16 bytes for 128 bits).
    * @param bigEndian If true, the highest bytes come first.

package/std/assembly/bignum/integer/i256.ts

@@ -1,3 +1,5 @@
+import { u256 } from './u256';
+
 export class i256 {
 
   constructor(
@@ -24,6 +26,17 @@ export class i256 {
     return new i256(u64.MAX_VALUE, u64.MAX_VALUE, u64.MAX_VALUE, 0x7FFFFFFFFFFFFFFF);
   }
 
+  /**
+   * Construct from a decimal (or `radix`) string. A leading `-` parses the magnitude
+   * and negates (two's complement), mirroring `i128.fromString`.
+   */
+  static fromString(str: string, radix: i32 = 10): i256 {
+    if (str.length > 0 && str.charCodeAt(0) == 0x2D /* '-' */) {
+      return changetype<i256>(u256.fromString(str.substring(1), radix)).neg();
+    }
+    return changetype<i256>(u256.fromString(str, radix));
+  }
+
   @inline @operator.prefix('!')
   static isEmpty(value: i256): bool {
     return value.isZero();
@@ -39,12 +52,31 @@ export class i256 {
     return !(this.lo1 | this.lo2 | this.hi1 | this.hi2);
   }
 
-  /*
-  @inline
-  static abs(value: i128): i128 {
-    return value < 0 ? value.neg() : value;
+  @inline @operator.prefix('-')
+  neg(): i256 {
+    // two's complement: ~x + 1, carrying across the four limbs
+    let l1 = ~(<u64>this.lo1);
+    let l2 = ~(<u64>this.lo2);
+    let h1 = ~(<u64>this.hi1);
+    let h2 = ~(<u64>this.hi2);
+    l1 += 1;
+    if (!l1) {
+      l2 += 1;
+      if (!l2) {
+        h1 += 1;
+        if (!h1) h2 += 1;
+      }
+    }
+    return new i256(<i64>l1, <i64>l2, <i64>h1, <i64>h2);
   }
-  */
 
-  // TODO
+  /**
+   * Decimal (or `radix`) string. Sign + unsigned magnitude: negate (two's complement)
+   * and reinterpret as u256, which is layout-identical. i256.Min survives because
+   * neg(Min) == Min and its bit pattern reinterpreted unsigned is exactly 2^255.
+   */
+  toString(radix: i32 = 10): string {
+    if (!this.isNeg()) return changetype<u256>(this).toString(radix);
+    return '-' + changetype<u256>(this.neg()).toString(radix);
+  }
 }

package/std/assembly/json.ts

@@ -126,6 +126,9 @@ export class JSON {
     }
 
     asI64(): i64 {
+        // 64-bit integers cross JSON as decimal strings (JS numbers lose precision past
+        // 2^53), so a string token reads as its integer value, not 0.
+        if (this.kind == JSON.STR) return this.str.length ? i64.parse(this.str) : 0;
         if (this.kind != JSON.NUM) return 0;
         if (this.numKind == JSON.N_I64) return this.inum;
         if (this.numKind == JSON.N_U64) return <i64>this.unum;
@@ -133,6 +136,8 @@ export class JSON {
     }
 
     asU64(): u64 {
+        // See asI64: decimal-string tokens are first-class for 64-bit integers.
+        if (this.kind == JSON.STR) return this.str.length ? u64.parse(this.str) : 0;
         if (this.kind != JSON.NUM) return 0;
         if (this.numKind == JSON.N_U64) return this.unum;
         if (this.numKind == JSON.N_I64) return <u64>this.inum;