@amxts/core 0.1.0

package/node_modules/assemblyscript/std/assembly/compat.ts

@@ -0,0 +1,2 @@
+export type ReturnType<T> = returnof<T>;
+export type NonNullable<T> = nonnull<T>;

package/node_modules/assemblyscript/std/assembly/console.ts

@@ -0,0 +1,42 @@
+import {
+  console as binding
+} from "./bindings/dom";
+
+export namespace console {
+
+  export function assert<T>(condition: T, message: string = ""): void {
+    binding.assert(!!condition, message);
+  }
+
+  export function log(message: string = ""): void {
+    binding.log(message);
+  }
+
+  export function debug(message: string = ""): void {
+    binding.debug(message);
+  }
+
+  export function info(message: string = ""): void {
+    binding.info(message);
+  }
+
+  export function warn(message: string = ""): void {
+    binding.warn(message);
+  }
+
+  export function error(message: string = ""): void {
+    binding.error(message);
+  }
+
+  export function time(label: string = "default"): void {
+    binding.time(label);
+  }
+
+  export function timeLog(label: string = "default"): void {
+    binding.timeLog(label);
+  }
+
+  export function timeEnd(label: string = "default"): void {
+    binding.timeEnd(label);
+  }
+}

package/node_modules/assemblyscript/std/assembly/crypto.ts

@@ -0,0 +1,9 @@
+import {
+  crypto as crypto_binding
+} from "bindings/dom";
+
+export namespace crypto {
+  export function getRandomValues(array: Uint8Array): void {
+    crypto_binding.getRandomValues(array);
+  }
+}

package/node_modules/assemblyscript/std/assembly/dataview.ts

@@ -0,0 +1,181 @@
+import { BLOCK_MAXSIZE } from "./rt/common";
+import { ArrayBuffer } from "./arraybuffer";
+import { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from "./util/error";
+
+// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte
+
+export class DataView {
+
+  readonly buffer: ArrayBuffer;
+  @unsafe readonly dataStart: usize;
+  readonly byteLength: i32;
+
+  get byteOffset(): i32 {
+    return <i32>(this.dataStart - changetype<usize>(this.buffer));
+  }
+
+  constructor(
+    buffer: ArrayBuffer,
+    byteOffset: i32 = 0,
+    byteLength: i32 = buffer.byteLength
+  ) {
+    if (
+      i32(<u32>byteLength > <u32>BLOCK_MAXSIZE) |
+      i32(<u32>byteOffset + byteLength > <u32>buffer.byteLength)
+    ) throw new RangeError(E_INVALIDLENGTH);
+    this.buffer = buffer; // links
+    let dataStart = changetype<usize>(buffer) + <usize>byteOffset;
+    this.dataStart = dataStart;
+    this.byteLength = byteLength;
+  }
+
+  getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    return littleEndian
+      ? load<f32>(this.dataStart + <usize>byteOffset)
+      : reinterpret<f32>(bswap<u32>(load<u32>(this.dataStart + <usize>byteOffset)));
+  }
+
+  getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    return littleEndian
+      ? load<f64>(this.dataStart + <usize>byteOffset)
+      : reinterpret<f64>(bswap<u64>(load<u64>(this.dataStart + <usize>byteOffset)));
+  }
+
+  getInt8(byteOffset: i32): i8 {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<i8>(this.dataStart + <usize>byteOffset);
+  }
+
+  getInt16(byteOffset: i32, littleEndian: bool = false): i16 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: i16 = load<i16>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u16>(result);
+  }
+
+  getInt32(byteOffset: i32, littleEndian: bool = false): i32 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: i32 = load<i32>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u32>(result);
+  }
+
+  getUint8(byteOffset: i32): u8 {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<u8>(this.dataStart + <usize>byteOffset);
+  }
+
+  getUint16(byteOffset: i32, littleEndian: bool = false): u16 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: u16 = load<u16>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u16>(result);
+  }
+
+  getUint32(byteOffset: i32, littleEndian: bool = false): u32 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: u32 = load<u32>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u32>(result);
+  }
+
+  setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    if (littleEndian) store<f32>(this.dataStart + <usize>byteOffset, value);
+    else store<u32>(this.dataStart + <usize>byteOffset, bswap<u32>(reinterpret<u32>(value)));
+  }
+
+  setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    if (littleEndian) store<f64>(this.dataStart + <usize>byteOffset, value);
+    else store<u64>(this.dataStart + <usize>byteOffset, bswap<u64>(reinterpret<u64>(value)));
+  }
+
+  setInt8(byteOffset: i32, value: i8): void {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i8>(this.dataStart + <usize>byteOffset, value);
+  }
+
+  setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i16>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u16>(value));
+  }
+
+  setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i32>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u32>(value));
+  }
+
+  setUint8(byteOffset: i32, value: u8): void {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u8>(this.dataStart + <usize>byteOffset, value);
+  }
+
+  setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u16>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u16>(value));
+  }
+
+  setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u32>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u32>(value));
+  }
+
+  // Non-standard additions that make sense in WebAssembly, but won't work in JS:
+
+  getInt64(byteOffset: i32, littleEndian: bool = false): i64 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: i64 = load<i64>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u64>(result);
+  }
+
+  getUint64(byteOffset: i32, littleEndian: bool = false): u64 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result = load<u64>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u64>(result);
+  }
+
+  setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i64>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u64>(value));
+  }
+
+  setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u64>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u64>(value));
+  }
+
+  toString(): string {
+    return "[object DataView]";
+  }
+}

package/node_modules/assemblyscript/std/assembly/date.ts

@@ -0,0 +1,373 @@
+import { E_INVALIDDATE } from "util/error";
+import { Date as Date_binding } from "./bindings/dom";
+
+// @ts-ignore: decorator
+@inline const
+  MILLIS_LIMIT      = 8640000000000000,
+  MILLIS_PER_DAY    = 1000 * 60 * 60 * 24,
+  MILLIS_PER_HOUR   = 1000 * 60 * 60,
+  MILLIS_PER_MINUTE = 1000 * 60,
+  MILLIS_PER_SECOND = 1000,
+  YEARS_PER_EPOCH   = 400,
+  DAYS_PER_EPOCH    = 146097, // 400 * 365 + 400 / 4 - 400 / 100 + 1
+  EPOCH_OFFSET      = 719468; // Jan 1, 1970
+
+// ymdFromEpochDays returns values via globals to avoid allocations
+// @ts-ignore: decorator
+@lazy let _month: i32, _day: i32;
+
+export class Date {
+  private year: i32 = 0;
+  private month: i32 = 0;
+  private day: i32 = 0;
+
+  @inline static UTC(
+    year: i32,
+    month: i32 = 0,
+    day: i32 = 1,
+    hour: i32 = 0,
+    minute: i32 = 0,
+    second: i32 = 0,
+    millisecond: i32 = 0
+  ): i64 {
+    if (year >= 0 && year <= 99) year += 1900;
+    let ms = epochMillis(year, month + 1, day, hour, minute, second, millisecond);
+    if (invalidDate(ms)) throw new RangeError(E_INVALIDDATE);
+    return ms;
+  }
+
+  @inline static now(): i64 {
+    return <i64>Date_binding.now();
+  }
+
+  // It can parse only ISO 8601 inputs like YYYY-MM-DDTHH:MM:SS.000Z
+  @inline static parse(dateString: string): Date {
+    return this.fromString(dateString);
+  }
+
+  static fromString(dateTimeString: string): Date {
+    if (!dateTimeString.length) throw new RangeError(E_INVALIDDATE);
+    var
+      hour: i32 = 0,
+      min: i32 = 0,
+      sec: i32 = 0,
+      ms: i32 = 0,
+      offsetMs: i32 = 0;
+
+    let dateString = dateTimeString;
+    let posT = dateTimeString.indexOf("T");
+    if (~posT) {
+      // includes a time component
+      let timeString: string;
+      dateString = dateTimeString.substring(0, posT);
+      timeString = dateTimeString.substring(posT + 1);
+
+      // might end with an offset ("Z", "+05:30", "-08:00", etc.)
+      for (let i = timeString.length - 1; i >= 0; i--) {
+        let c = timeString.charCodeAt(i);
+        if (c == 90) { // Z
+          timeString = timeString.substring(0, i);
+          break;
+        } else if (c == 43 || c == 45) { // + or -
+          if (i == timeString.length - 1) {
+            throw new RangeError(E_INVALIDDATE);
+          }
+
+          let posColon = timeString.indexOf(":", i + 1);
+          if (~posColon) {
+            let offsetHours = i32.parse(timeString.substring(i + 1, posColon));
+            let offsetMinutes = i32.parse(timeString.substring(posColon + 1));
+            offsetMs = (offsetHours * 60 + offsetMinutes) * MILLIS_PER_MINUTE;
+          } else {
+            let offsetHours = i32.parse(timeString.substring(i + 1));
+            offsetMs = offsetHours * MILLIS_PER_HOUR;
+          }
+
+          if (c == 45) offsetMs = -offsetMs; // negative offset
+          timeString = timeString.substring(0, i);
+          break;
+        }
+      }
+
+      // parse the HH:MM:SS component
+      let timeParts = timeString.split(":");
+      let len = timeParts.length;
+      if (len <= 1) throw new RangeError(E_INVALIDDATE);
+
+      hour = i32.parse(timeParts[0]);
+      min  = i32.parse(timeParts[1]);
+      if (len >= 3) {
+        let secAndFrac = timeParts[2];
+        let posDot = secAndFrac.indexOf(".");
+        if (~posDot) {
+          // includes fractional seconds (truncate to milliseconds)
+          sec = i32.parse(secAndFrac.substring(0, posDot));
+          ms  = i32.parse(secAndFrac.substr(posDot + 1, 3).padEnd(3, "0"));
+        } else {
+          sec = i32.parse(secAndFrac);
+        }
+      }
+    }
+
+    // parse the YYYY-MM-DD component
+    let parts = dateString.split("-");
+    let year = i32.parse(parts[0]);
+    let month = 1, day = 1;
+    let len = parts.length;
+    if (len >= 2) {
+      month = i32.parse(parts[1]);
+      if (len >= 3) {
+        day = i32.parse(parts[2]);
+      }
+    }
+
+    return new Date(epochMillis(year, month, day, hour, min, sec, ms) - offsetMs);
+  }
+
+  constructor(private epochMillis: i64) {
+    // this differs from JavaScript which prefer return NaN or "Invalid Date" string
+    // instead throwing exception.
+    if (invalidDate(epochMillis)) throw new RangeError(E_INVALIDDATE);
+
+    this.year = dateFromEpoch(epochMillis);
+    this.month = _month;
+    this.day = _day;
+  }
+
+  @inline getTime(): i64 {
+    return this.epochMillis;
+  }
+
+  setTime(time: i64): i64 {
+    if (invalidDate(time)) throw new RangeError(E_INVALIDDATE);
+
+    this.epochMillis = time;
+    this.year = dateFromEpoch(time);
+    this.month = _month;
+    this.day = _day;
+
+    return time;
+  }
+
+  @inline getUTCFullYear(): i32 {
+    return this.year;
+  }
+
+  @inline getUTCMonth(): i32 {
+    return this.month - 1;
+  }
+
+  @inline getUTCDate(): i32 {
+    return this.day;
+  }
+
+  @inline getUTCDay(): i32 {
+    return dayOfWeek(this.year, this.month, this.day);
+  }
+
+  getUTCHours(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_DAY)) / MILLIS_PER_HOUR;
+  }
+
+  getUTCMinutes(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_HOUR)) / MILLIS_PER_MINUTE;
+  }
+
+  getUTCSeconds(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_MINUTE)) / MILLIS_PER_SECOND;
+  }
+
+  getUTCMilliseconds(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_SECOND));
+  }
+
+  setUTCMilliseconds(millis: i32): void {
+    this.setTime(this.epochMillis + (millis - this.getUTCMilliseconds()));
+  }
+
+  setUTCSeconds(seconds: i32): void {
+    this.setTime(this.epochMillis + (seconds - this.getUTCSeconds()) * MILLIS_PER_SECOND);
+  }
+
+  setUTCMinutes(minutes: i32): void {
+    this.setTime(this.epochMillis + (minutes - this.getUTCMinutes()) * MILLIS_PER_MINUTE);
+  }
+
+  setUTCHours(hours: i32): void {
+    this.setTime(this.epochMillis + (hours - this.getUTCHours()) * MILLIS_PER_HOUR);
+  }
+
+  setUTCDate(day: i32): void {
+    if (this.day == day) return;
+    this.setTime(join(this.year, this.month, day, this.epochMillis));
+  }
+
+  setUTCMonth(month: i32, day: i32 = this.day): void {
+    if (this.month == month + 1) return;
+    this.setTime(join(this.year, month + 1, day, this.epochMillis));
+  }
+
+  setUTCFullYear(year: i32): void {
+    if (this.year == year) return;
+    this.setTime(join(year, this.month, this.day, this.epochMillis));
+  }
+
+  toISOString(): string {
+    // TODO: add more low-level helper which combine toString and padStart without extra allocation
+
+    let yr = this.year;
+    let isNeg = yr < 0;
+    let year = (isNeg || yr >= 10000)
+      ? (isNeg ? "-" : "+") + stringify(abs(yr), 6)
+      : stringify(yr, 4);
+    let month = stringify(this.month, 2);
+    let day = stringify(this.day);
+    let hours = stringify(this.getUTCHours());
+    let mins = stringify(this.getUTCMinutes());
+    let secs = stringify(this.getUTCSeconds());
+    let ms = stringify(this.getUTCMilliseconds(), 3);
+
+    return `${year}-${month}-${day}T${hours}:${mins}:${secs}.${ms}Z`;
+  }
+
+  toUTCString(): string {
+    const
+      weeks: StaticArray<string> = [
+        "Sun, ", "Mon, ", "Tue, ", "Wed, ", "Thu, ", "Fri, ", "Sat, "
+      ],
+      months: StaticArray<string> = [
+        " Jan ", " Feb ", " Mar ", " Apr ", " May ", " Jun ",
+        " Jul ", " Aug ", " Sep ", " Oct ", " Nov ", " Dec "
+      ];
+
+    let mo = this.month;
+    let da = this.day;
+    let yr = this.year;
+    let wd = dayOfWeek(yr, mo, da);
+    let year = stringify(abs(yr), 4);
+    let month = unchecked(months[mo - 1]);
+    let week = unchecked(weeks[wd]);
+    let day = stringify(da);
+    let hours = stringify(this.getUTCHours());
+    let mins = stringify(this.getUTCMinutes());
+    let secs = stringify(this.getUTCSeconds());
+
+    return `${week}${day}${month}${yr < 0 ? "-" : ""}${year} ${hours}:${mins}:${secs} GMT`;
+  }
+
+  toDateString(): string {
+    // TODO: use u64 static data instead 4 chars
+    // also use stream itoa variants.
+    const
+      weeks: StaticArray<string> = [
+        "Sun ", "Mon ", "Tue ", "Wed ", "Thu ", "Fri ", "Sat "
+      ],
+      months: StaticArray<string> = [
+        "Jan ", "Feb ", "Mar ", "Apr ", "May ", "Jun ",
+        "Jul ", "Aug ", "Sep ", "Oct ", "Nov ", "Dec "
+      ];
+
+    let mo = this.month;
+    let da = this.day;
+    let yr = this.year;
+    let wd = dayOfWeek(yr, mo, da);
+    let year = stringify(abs(yr), 4);
+    let month = unchecked(months[mo - 1]);
+    let week = unchecked(weeks[wd]);
+    let day = stringify(da);
+
+    return `${week}${month}${day}${yr < 0 ? " -" : " "}${year}`;
+  }
+
+  // Note: it uses UTC time instead local time (without timezone offset)
+  toTimeString(): string {
+    let hours = stringify(this.getUTCHours());
+    let mins = stringify(this.getUTCMinutes());
+    let secs = stringify(this.getUTCSeconds());
+    // TODO: add timezone
+    return `${hours}:${mins}:${secs}`;
+  }
+
+  // Note: it uses UTC datetime instead local datetime (without timezone offset)
+  toString(): string {
+    return `${this.toDateString()} ${this.toTimeString()}`;
+  }
+}
+
+function epochMillis(
+  year: i32,
+  month: i32,
+  day: i32,
+  hour: i32,
+  minute: i32,
+  second: i32,
+  milliseconds: i32
+): i64 {
+  return (
+    daysSinceEpoch(year, month, day) * MILLIS_PER_DAY +
+    hour * MILLIS_PER_HOUR +
+    minute * MILLIS_PER_MINUTE +
+    second * MILLIS_PER_SECOND +
+    milliseconds
+  );
+}
+
+// @ts-ignore: decorator
+@inline function floorDiv<T extends number>(a: T, b: T): T {
+  return (a - (a < 0 ? b - 1 : 0)) / b as T;
+}
+
+// @ts-ignore: decorator
+@inline function euclidRem<T extends number>(a: T, b: T): T {
+  let m = a % b;
+  return m + (m < 0 ? b : 0) as T;
+}
+
+function invalidDate(millis: i64): bool {
+  // @ts-ignore
+  return (millis < -MILLIS_LIMIT) | (millis > MILLIS_LIMIT);
+}
+
+// Based on "Euclidean Affine Functions and Applications to Calendar Algorithms"
+// Paper: https://arxiv.org/pdf/2102.06959.pdf
+function dateFromEpoch(ms: i64): i32 {
+  let da = (<i32>floorDiv(ms, MILLIS_PER_DAY) * 4 + EPOCH_OFFSET * 4) | 3;
+  let q0 = floorDiv(da, DAYS_PER_EPOCH);  // [0, 146096]
+  let r1 = <u32>da - q0 * DAYS_PER_EPOCH;
+  let u1 = u64(r1 | 3) * 2939745;
+  let dm1 = <u32>u1 / 11758980;
+  let n1 = 2141 * dm1 + 197913;
+  let year = 100 * q0 + i32(u1 >>> 32);
+  _day = (n1 & 0xFFFF) / 2141 + 1;              // [1, 31]
+  _month = (n1 >>> 16) - (dm1 >= 306 ? 12 : 0); // [1, 12]
+  return year + (dm1 >= 306 ?  1 : 0);
+}
+
+// http://howardhinnant.github.io/date_algorithms.html#days_from_civil
+function daysSinceEpoch(year: i32, month: i32, day: i32): i64 {
+  year -= i32(month <= 2);
+  let era = <u32>floorDiv(year, YEARS_PER_EPOCH);
+  let yoe = <u32>year - era * YEARS_PER_EPOCH; // [0, 399]
+  let doy = <u32>(153 * (month + (month > 2 ? -3 : 9)) + 2) / 5 + day - 1; // [0, 365]
+  let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; // [0, 146096]
+  return <i64><i32>(era * 146097 + doe - EPOCH_OFFSET);
+}
+
+// TomohikoSakamoto algorithm from https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week
+function dayOfWeek(year: i32, month: i32, day: i32): i32 {
+  const tab = memory.data<u8>([0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4]);
+
+  year -= i32(month <= 2);
+  const cent = floorDiv(year >> 2, 100 >> 2);
+  year += (year >> 2) - cent + (cent >> 2);
+  month = <i32>load<u8>(tab + month - 1);
+  return euclidRem(year + month + day, 7);
+}
+
+function stringify(value: i32, padding: i32 = 2): string {
+  return value.toString().padStart(padding, "0");
+}
+
+function join(year: i32, month: i32, day: i32, ms: i64): i64 {
+  return daysSinceEpoch(year, month, day) * MILLIS_PER_DAY + euclidRem(ms, MILLIS_PER_DAY);
+}

package/node_modules/assemblyscript/std/assembly/diagnostics.ts

@@ -0,0 +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;

package/node_modules/assemblyscript/std/assembly/error.ts

@@ -0,0 +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";
+  }
+}