toilscript 0.0.1 → 0.1.1

package/std/assembly/diagnostics.ts

@@ -1,11 +1,11 @@
-// @ts-ignore: decorator
-@builtin
-export declare function ERROR(message?: string): void;
-
-// @ts-ignore: decorator
-@builtin
-export declare function WARNING(message?: string): void;
-
-// @ts-ignore: decorator
-@builtin
-export declare function INFO(message?: string): void;
+// @ts-ignore: decorator
+@builtin
+export declare function ERROR(message?: string): void;
+
+// @ts-ignore: decorator
+@builtin
+export declare function WARNING(message?: string): void;
+
+// @ts-ignore: decorator
+@builtin
+export declare function INFO(message?: string): void;

package/std/assembly/encoding.ts

@@ -1,151 +1,151 @@
-import { Pointer } from "./pointer";
-
-// Hex and varint encoding utilities.
-// Inline functions for zero-overhead encoding/decoding.
-
-export namespace Encoding {
-
-  export namespace Hex {
-    /** Encode bytes at `src` (length `srcLen`) to hex chars at `dst`. Returns chars written (srcLen * 2). */
-    @inline export function encode(src: usize, srcLen: i32, dst: usize): i32 {
-      for (let i: i32 = 0; i < srcLen; ++i) {
-        encodeByte(load<u8>(src + <usize>i), dst + <usize>(i << 1));
-      }
-      return srcLen << 1;
-    }
-
-    /** Decode hex chars at `src` (length `srcLen`, must be even) to bytes at `dst`. Returns bytes written, or -1 on error. */
-    @inline export function decode(src: usize, srcLen: i32, dst: usize): i32 {
-      if (srcLen & 1) return -1; // odd length
-      let outLen = srcLen >> 1;
-      for (let i: i32 = 0; i < outLen; ++i) {
-        let b = decodeByte(src + <usize>(i << 1));
-        if (b < 0) return -1;
-        store<u8>(dst + <usize>i, <u8>b);
-      }
-      return outLen;
-    }
-
-    /** Encode a single byte to 2 hex chars at `dst`. */
-    @inline export function encodeByte(value: u8, dst: usize): void {
-      let hi = (value >>> 4) & 0x0F;
-      let lo = value & 0x0F;
-      store<u8>(dst, hi < 10 ? hi + 48 : hi + 87);      // '0'-'9' or 'a'-'f'
-      store<u8>(dst + 1, lo < 10 ? lo + 48 : lo + 87);
-    }
-
-    /** Decode 2 hex chars at `src` to a byte value. Returns -1 on invalid input. */
-    @inline export function decodeByte(src: usize): i32 {
-      let hi = decodeNibble(load<u8>(src));
-      let lo = decodeNibble(load<u8>(src + 1));
-      if ((hi | lo) < 0) return -1;
-      return (hi << 4) | lo;
-    }
-
-    // Internal nibble decoder
-    @inline function decodeNibble(c: u8): i32 {
-      if (c >= 48 && c <= 57) return <i32>(c - 48);       // '0'-'9'
-      if (c >= 97 && c <= 102) return <i32>(c - 87);      // 'a'-'f'
-      if (c >= 65 && c <= 70) return <i32>(c - 55);       // 'A'-'F'
-      return -1;
-    }
-  }
-
-  export namespace Varint {
-    /** Encode a u32 as unsigned LEB128 at `dst`. Returns bytes written. */
-    @inline export function encodeU32(value: u32, dst: usize): i32 {
-      let i: i32 = 0;
-      while (value >= 0x80) {
-        store<u8>(dst + <usize>i, <u8>((value & 0x7F) | 0x80));
-        value >>= 7;
-        ++i;
-      }
-      store<u8>(dst + <usize>i, <u8>value);
-      return i + 1;
-    }
-
-    /** Encode a u64 as unsigned LEB128 at `dst`. Returns bytes written. */
-    @inline export function encodeU64(value: u64, dst: usize): i32 {
-      let i: i32 = 0;
-      while (value >= 0x80) {
-        store<u8>(dst + <usize>i, <u8>((<u32>(value & 0x7F)) | 0x80));
-        value >>= 7;
-        ++i;
-      }
-      store<u8>(dst + <usize>i, <u8><u32>value);
-      return i + 1;
-    }
-
-    /** Decode an unsigned LEB128-encoded u32 from `src`. Writes bytes consumed to `bytesRead`. Max 5 bytes. */
-    @inline export function decodeU32(src: usize, bytesRead: Pointer<i32>): u32 {
-      let result: u32 = 0;
-      let shift: u32 = 0;
-      let i: i32 = 0;
-      let b: u8;
-      do {
-        b = load<u8>(src + <usize>i);
-        result |= <u32>(b & 0x7F) << shift;
-        shift += 7;
-        ++i;
-        if (i >= 5) break; // u32 needs at most 5 LEB128 bytes
-      } while (b & 0x80);
-      bytesRead.value = i;
-      return result;
-    }
-
-    /** Decode an unsigned LEB128-encoded u64 from `src`. Writes bytes consumed to `bytesRead`. Max 10 bytes. */
-    @inline export function decodeU64(src: usize, bytesRead: Pointer<i32>): u64 {
-      let result: u64 = 0;
-      let shift: u64 = 0;
-      let i: i32 = 0;
-      let b: u8;
-      do {
-        b = load<u8>(src + <usize>i);
-        result |= <u64>(b & 0x7F) << shift;
-        shift += 7;
-        ++i;
-        if (i >= 10) break; // u64 needs at most 10 LEB128 bytes
-      } while (b & 0x80);
-      bytesRead.value = i;
-      return result;
-    }
-
-    /** Encode a u64 as Bitcoin CompactSize at `dst`. Returns bytes written. */
-    @inline export function encodeCompact(value: u64, dst: usize): i32 {
-      if (value < 0xFD) {
-        store<u8>(dst, <u8><u32>value);
-        return 1;
-      } else if (value <= 0xFFFF) {
-        store<u8>(dst, 0xFD);
-        store<u16>(dst + 1, <u16><u32>value); // LE
-        return 3;
-      } else if (value <= 0xFFFFFFFF) {
-        store<u8>(dst, 0xFE);
-        store<u32>(dst + 1, <u32>value); // LE
-        return 5;
-      } else {
-        store<u8>(dst, 0xFF);
-        store<u64>(dst + 1, value); // LE
-        return 9;
-      }
-    }
-
-    /** Decode a Bitcoin CompactSize from `src`. Writes bytes consumed to `bytesRead`. */
-    @inline export function decodeCompact(src: usize, bytesRead: Pointer<i32>): u64 {
-      let first = load<u8>(src);
-      if (first < 0xFD) {
-        bytesRead.value = 1;
-        return <u64>first;
-      } else if (first == 0xFD) {
-        bytesRead.value = 3;
-        return <u64>load<u16>(src + 1);
-      } else if (first == 0xFE) {
-        bytesRead.value = 5;
-        return <u64>load<u32>(src + 1);
-      } else {
-        bytesRead.value = 9;
-        return load<u64>(src + 1);
-      }
-    }
-  }
-}
+import { Pointer } from "./pointer";
+
+// Hex and varint encoding utilities.
+// Inline functions for zero-overhead encoding/decoding.
+
+export namespace Encoding {
+
+  export namespace Hex {
+    /** Encode bytes at `src` (length `srcLen`) to hex chars at `dst`. Returns chars written (srcLen * 2). */
+    @inline export function encode(src: usize, srcLen: i32, dst: usize): i32 {
+      for (let i: i32 = 0; i < srcLen; ++i) {
+        encodeByte(load<u8>(src + <usize>i), dst + <usize>(i << 1));
+      }
+      return srcLen << 1;
+    }
+
+    /** Decode hex chars at `src` (length `srcLen`, must be even) to bytes at `dst`. Returns bytes written, or -1 on error. */
+    @inline export function decode(src: usize, srcLen: i32, dst: usize): i32 {
+      if (srcLen & 1) return -1; // odd length
+      let outLen = srcLen >> 1;
+      for (let i: i32 = 0; i < outLen; ++i) {
+        let b = decodeByte(src + <usize>(i << 1));
+        if (b < 0) return -1;
+        store<u8>(dst + <usize>i, <u8>b);
+      }
+      return outLen;
+    }
+
+    /** Encode a single byte to 2 hex chars at `dst`. */
+    @inline export function encodeByte(value: u8, dst: usize): void {
+      let hi = (value >>> 4) & 0x0F;
+      let lo = value & 0x0F;
+      store<u8>(dst, hi < 10 ? hi + 48 : hi + 87);      // '0'-'9' or 'a'-'f'
+      store<u8>(dst + 1, lo < 10 ? lo + 48 : lo + 87);
+    }
+
+    /** Decode 2 hex chars at `src` to a byte value. Returns -1 on invalid input. */
+    @inline export function decodeByte(src: usize): i32 {
+      let hi = decodeNibble(load<u8>(src));
+      let lo = decodeNibble(load<u8>(src + 1));
+      if ((hi | lo) < 0) return -1;
+      return (hi << 4) | lo;
+    }
+
+    // Internal nibble decoder
+    @inline function decodeNibble(c: u8): i32 {
+      if (c >= 48 && c <= 57) return <i32>(c - 48);       // '0'-'9'
+      if (c >= 97 && c <= 102) return <i32>(c - 87);      // 'a'-'f'
+      if (c >= 65 && c <= 70) return <i32>(c - 55);       // 'A'-'F'
+      return -1;
+    }
+  }
+
+  export namespace Varint {
+    /** Encode a u32 as unsigned LEB128 at `dst`. Returns bytes written. */
+    @inline export function encodeU32(value: u32, dst: usize): i32 {
+      let i: i32 = 0;
+      while (value >= 0x80) {
+        store<u8>(dst + <usize>i, <u8>((value & 0x7F) | 0x80));
+        value >>= 7;
+        ++i;
+      }
+      store<u8>(dst + <usize>i, <u8>value);
+      return i + 1;
+    }
+
+    /** Encode a u64 as unsigned LEB128 at `dst`. Returns bytes written. */
+    @inline export function encodeU64(value: u64, dst: usize): i32 {
+      let i: i32 = 0;
+      while (value >= 0x80) {
+        store<u8>(dst + <usize>i, <u8>((<u32>(value & 0x7F)) | 0x80));
+        value >>= 7;
+        ++i;
+      }
+      store<u8>(dst + <usize>i, <u8><u32>value);
+      return i + 1;
+    }
+
+    /** Decode an unsigned LEB128-encoded u32 from `src`. Writes bytes consumed to `bytesRead`. Max 5 bytes. */
+    @inline export function decodeU32(src: usize, bytesRead: Pointer<i32>): u32 {
+      let result: u32 = 0;
+      let shift: u32 = 0;
+      let i: i32 = 0;
+      let b: u8;
+      do {
+        b = load<u8>(src + <usize>i);
+        result |= <u32>(b & 0x7F) << shift;
+        shift += 7;
+        ++i;
+        if (i >= 5) break; // u32 needs at most 5 LEB128 bytes
+      } while (b & 0x80);
+      bytesRead.value = i;
+      return result;
+    }
+
+    /** Decode an unsigned LEB128-encoded u64 from `src`. Writes bytes consumed to `bytesRead`. Max 10 bytes. */
+    @inline export function decodeU64(src: usize, bytesRead: Pointer<i32>): u64 {
+      let result: u64 = 0;
+      let shift: u64 = 0;
+      let i: i32 = 0;
+      let b: u8;
+      do {
+        b = load<u8>(src + <usize>i);
+        result |= <u64>(b & 0x7F) << shift;
+        shift += 7;
+        ++i;
+        if (i >= 10) break; // u64 needs at most 10 LEB128 bytes
+      } while (b & 0x80);
+      bytesRead.value = i;
+      return result;
+    }
+
+    /** Encode a u64 as Bitcoin CompactSize at `dst`. Returns bytes written. */
+    @inline export function encodeCompact(value: u64, dst: usize): i32 {
+      if (value < 0xFD) {
+        store<u8>(dst, <u8><u32>value);
+        return 1;
+      } else if (value <= 0xFFFF) {
+        store<u8>(dst, 0xFD);
+        store<u16>(dst + 1, <u16><u32>value); // LE
+        return 3;
+      } else if (value <= 0xFFFFFFFF) {
+        store<u8>(dst, 0xFE);
+        store<u32>(dst + 1, <u32>value); // LE
+        return 5;
+      } else {
+        store<u8>(dst, 0xFF);
+        store<u64>(dst + 1, value); // LE
+        return 9;
+      }
+    }
+
+    /** Decode a Bitcoin CompactSize from `src`. Writes bytes consumed to `bytesRead`. */
+    @inline export function decodeCompact(src: usize, bytesRead: Pointer<i32>): u64 {
+      let first = load<u8>(src);
+      if (first < 0xFD) {
+        bytesRead.value = 1;
+        return <u64>first;
+      } else if (first == 0xFD) {
+        bytesRead.value = 3;
+        return <u64>load<u16>(src + 1);
+      } else if (first == 0xFE) {
+        bytesRead.value = 5;
+        return <u64>load<u32>(src + 1);
+      } else {
+        bytesRead.value = 9;
+        return load<u64>(src + 1);
+      }
+    }
+  }
+}

package/std/assembly/endian.ts

@@ -1,45 +1,45 @@
-// Zero-overhead endian conversion utilities.
-// Wasm is little-endian; protocols (Bitcoin, networking) often need big-endian.
-
-export namespace Endian {
-
-  /** Load a value from memory in big-endian byte order. */
-  @inline export function loadBE<T>(ptr: usize, offset: usize = 0): T {
-    return bswap<T>(load<T>(ptr + offset));
-  }
-
-  /** Store a value to memory in big-endian byte order. */
-  @inline export function storeBE<T>(ptr: usize, value: T, offset: usize = 0): void {
-    store<T>(ptr + offset, bswap<T>(value));
-  }
-
-  /** Load a value from memory in little-endian byte order (identity on wasm). */
-  @inline export function loadLE<T>(ptr: usize, offset: usize = 0): T {
-    return load<T>(ptr + offset);
-  }
-
-  /** Store a value to memory in little-endian byte order (identity on wasm). */
-  @inline export function storeLE<T>(ptr: usize, value: T, offset: usize = 0): void {
-    store<T>(ptr + offset, value);
-  }
-
-  /** Convert a value to big-endian byte order (bswap on wasm). */
-  @inline export function toBE<T>(value: T): T {
-    return bswap<T>(value);
-  }
-
-  /** Convert a value from big-endian byte order (bswap on wasm). */
-  @inline export function fromBE<T>(value: T): T {
-    return bswap<T>(value);
-  }
-
-  /** Convert a value to little-endian byte order (identity on wasm). */
-  @inline export function toLE<T>(value: T): T {
-    return value;
-  }
-
-  /** Convert a value from little-endian byte order (identity on wasm). */
-  @inline export function fromLE<T>(value: T): T {
-    return value;
-  }
-}
+// Zero-overhead endian conversion utilities.
+// Wasm is little-endian; protocols (Bitcoin, networking) often need big-endian.
+
+export namespace Endian {
+
+  /** Load a value from memory in big-endian byte order. */
+  @inline export function loadBE<T>(ptr: usize, offset: usize = 0): T {
+    return bswap<T>(load<T>(ptr + offset));
+  }
+
+  /** Store a value to memory in big-endian byte order. */
+  @inline export function storeBE<T>(ptr: usize, value: T, offset: usize = 0): void {
+    store<T>(ptr + offset, bswap<T>(value));
+  }
+
+  /** Load a value from memory in little-endian byte order (identity on wasm). */
+  @inline export function loadLE<T>(ptr: usize, offset: usize = 0): T {
+    return load<T>(ptr + offset);
+  }
+
+  /** Store a value to memory in little-endian byte order (identity on wasm). */
+  @inline export function storeLE<T>(ptr: usize, value: T, offset: usize = 0): void {
+    store<T>(ptr + offset, value);
+  }
+
+  /** Convert a value to big-endian byte order (bswap on wasm). */
+  @inline export function toBE<T>(value: T): T {
+    return bswap<T>(value);
+  }
+
+  /** Convert a value from big-endian byte order (bswap on wasm). */
+  @inline export function fromBE<T>(value: T): T {
+    return bswap<T>(value);
+  }
+
+  /** Convert a value to little-endian byte order (identity on wasm). */
+  @inline export function toLE<T>(value: T): T {
+    return value;
+  }
+
+  /** Convert a value from little-endian byte order (identity on wasm). */
+  @inline export function fromLE<T>(value: T): T {
+    return value;
+  }
+}

package/std/assembly/error.ts

@@ -1,44 +1,44 @@
-export class Error {
-
-  name: string  = "Error";
-  stack: string = ""; // TODO
-
-  constructor(
-    public message: string = ""
-  ) {}
-
-  toString(): string {
-    let message = this.message;
-    return message.length
-      ? this.name + ": " + message
-      : this.name;
-  }
-}
-
-export class RangeError extends Error {
-  constructor(message: string = "") {
-    super(message);
-    this.name = "RangeError";
-  }
-}
-
-export class TypeError extends Error {
-  constructor(message: string = "") {
-    super(message);
-    this.name = "TypeError";
-  }
-}
-
-export class SyntaxError extends Error {
-  constructor(message: string = "") {
-    super(message);
-    this.name = "SyntaxError";
-  }
-}
-
-export class URIError extends Error {
-  constructor(message: string = "") {
-    super(message);
-    this.name = "URIError";
-  }
-}
+export class Error {
+
+  name: string  = "Error";
+  stack: string = ""; // TODO
+
+  constructor(
+    public message: string = ""
+  ) {}
+
+  toString(): string {
+    let message = this.message;
+    return message.length
+      ? this.name + ": " + message
+      : this.name;
+  }
+}
+
+export class RangeError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "RangeError";
+  }
+}
+
+export class TypeError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "TypeError";
+  }
+}
+
+export class SyntaxError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "SyntaxError";
+  }
+}
+
+export class URIError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "URIError";
+  }
+}