Convert files to ReScript syntax. BigInt is a bit weird but otherwise seems fine.

Author: TheSpyder

src/Assert.re

@@ -0,0 +1,31 @@
+@module("assert") external ok: 'a => unit = "ok"
+@module("assert") external equal: ('a, 'a) => unit = "equal"
+@module("assert") external notEqual: ('a, 'a) => unit = "notEqual"
+@module("assert") external deepEqual: ('a, 'a) => unit = "deepEqual"
+@module("assert") external notDeepEqual: ('a, 'a) => unit = "notDeepEqual"
+@module("assert") external strictEqual: ('a, 'a) => unit = "strictEqual"
+@module("assert")
+external notStrictEqual: ('a, 'a) => unit = "notStrictEqual"
+@module("assert")
+external deepStrictEqual: ('a, 'a) => unit = "deepStrictEqual"
+@module("assert")
+external notDeepStrictEqual: ('a, 'a) => unit = "notDeepStrictEqual"
+@module("assert")
+external throws: (@uncurry (unit => 'a)) => unit = "throws"
+@module("assert")
+external throwsError: (@uncurry (unit => 'a), 'e) => unit = "throws"
+@module("assert")
+external doesNotThrow: (@uncurry (unit => 'a)) => unit = "doesNotThrow"
+@module("assert")
+external doesNotThrowError: (@uncurry (unit => 'a), 'e) => unit = "doesNotThrow"
+@module("assert") external ifError: 'a => unit = "ifError"
+@module("assert")
+external rejects: (@uncurry (unit => Js.Promise.t<'a>)) => unit = "rejects"
+@module("assert")
+external rejectsError: (@uncurry (unit => Js.Promise.t<'a>), 'e) => unit = "rejects"
+@module("assert")
+external doesNotReject: (@uncurry (unit => Js.Promise.t<'a>)) => unit = "doesNotReject"
+@module("assert")
+external doesNotRejectError: (@uncurry (unit => Js.Promise.t<'a>), 'e) => unit = "doesNotReject"
+
+module AssertionError = Errors.AssertionError

src/Assert.res

@@ -0,0 +1,35 @@
+type t
+
+@val external fromInt: int => t = "BigInt"
+@val external fromFloat: float => t = "BigInt"
+@val external toInt: t => int = "Number"
+
+%%private(let _NEGATIVE_ONE = fromInt(-1))
+
+external \"~-": t => t = "%negfloat"
+external \"+": (t, t) => t = "%addfloat"
+external \"-": (t, t) => t = "%subfloat"
+external \"*": (t, t) => t = "%mulfloat"
+external \"/": (t, t) => t = "%divfloat"
+let mod: (t, t) => t = Obj.magic(mod_float)
+let \"**": (t, t) => t = %raw(`function (a, b) { return (a ** b); }`)
+external land: (t, t) => t = "%andint"
+external lor: (t, t) => t = "%orint"
+external lxor: (t, t) => t = "%xorint"
+let lnot: t => t = x => lxor(x, _NEGATIVE_ONE)
+external lsl: (t, t) => t = "%lslint"
+external asr: (t, t) => t = "%asrint"
+
+external negate: t => t = "%negfloat"
+external add: (t, t) => t = "%addfloat"
+external subtract: (t, t) => t = "%subfloat"
+external multiply: (t, t) => t = "%mulfloat"
+external divide: (t, t) => t = "%divfloat"
+let modulo: (t, t) => t = Obj.magic(mod_float)
+let power: (t, t) => t = \"**"
+external logicalAnd: (t, t) => t = "%andint"
+external logicalOr: (t, t) => t = "%orint"
+external logicalXor: (t, t) => t = "%xorint"
+let logicalNot: t => t = x => lxor(x, _NEGATIVE_ONE)
+external logicalShiftLeft: (t, t) => t = "%lslint"
+external arithmeticShiftRight: (t, t) => t = "%asrint"

src/BigInt.re

@@ -0,0 +1,103 @@
+module Impl: {
+  open Js.TypedArray2
+
+  type t
+
+  type case =
+    | String(string)
+    | Buffer(Buffer.t)
+    | Uint8Array(Uint8Array.t)
+    | Int8Array(Int8Array.t)
+    | Uint8ClampedArray(Uint8ClampedArray.t)
+    | Uint16Array(Uint16Array.t)
+    | Int16Array(Int16Array.t)
+    | Uint32Array(Uint32Array.t)
+    | Int32Array(Uint32Array.t)
+    | Float32Array(Float32Array.t)
+    | Float64Array(Float64Array.t)
+    | DataView(DataView.t)
+    | Unknown(t)
+
+  let string: string => t
+  let buffer: Buffer.t => t
+  let int8Array: Int8Array.t => t
+  let uInt8Array: Uint8Array.t => t
+  let uInt8ClampedArray: Uint8ClampedArray.t => t
+  let uInt16Array: Uint16Array.t => t
+  let int16Array: Int16Array.t => t
+  let uInt32Array: Uint32Array.t => t
+  let int32Array: Int32Array.t => t
+  let float32Array: Float32Array.t => t
+  let float64Array: Float64Array.t => t
+  let dataView: DataView.t => t
+  let classify: t => case
+} = {
+  open Js.TypedArray2
+
+  @unboxed
+  type rec t = BinaryLike('a): t
+
+  type case =
+    | String(string)
+    | Buffer(Buffer.t)
+    | Uint8Array(Uint8Array.t)
+    | Int8Array(Int8Array.t)
+    | Uint8ClampedArray(Uint8ClampedArray.t)
+    | Uint16Array(Uint16Array.t)
+    | Int16Array(Int16Array.t)
+    | Uint32Array(Uint32Array.t)
+    | Int32Array(Uint32Array.t)
+    | Float32Array(Float32Array.t)
+    | Float64Array(Float64Array.t)
+    | DataView(DataView.t)
+    | Unknown(t)
+
+  let string: string => t = x => BinaryLike(x)
+  let buffer: Buffer.t => t = x => BinaryLike(x)
+  let int8Array: Int8Array.t => t = x => BinaryLike(x)
+  let uInt8Array: Uint8Array.t => t = x => BinaryLike(x)
+  let uInt8ClampedArray: Uint8ClampedArray.t => t = x => BinaryLike(x)
+  let uInt16Array: Uint16Array.t => t = x => BinaryLike(x)
+  let int16Array: Int16Array.t => t = x => BinaryLike(x)
+  let uInt32Array: Uint32Array.t => t = x => BinaryLike(x)
+  let int32Array: Int32Array.t => t = x => BinaryLike(x)
+  let float32Array: Float32Array.t => t = x => BinaryLike(x)
+  let float64Array: Float64Array.t => t = x => BinaryLike(x)
+  let dataView: DataView.t => t = x => BinaryLike(x)
+
+  let classify: t => case = x =>
+    switch x {
+    | BinaryLike(binaryLike) =>
+      if Js.typeof(binaryLike) === "string" {
+        String(Obj.magic(binaryLike))
+      } else if Buffer.isBuffer(binaryLike) {
+        Buffer(Obj.magic(binaryLike))
+      } else if Util.Types.isInt8Array(binaryLike) {
+        Int8Array(Obj.magic(binaryLike))
+      } else if Util.Types.isUint8Array(binaryLike) {
+        Uint8Array(Obj.magic(binaryLike))
+      } else if Util.Types.isUint8ClampedArray(binaryLike) {
+        Uint8ClampedArray(Obj.magic(binaryLike))
+      } else if Util.Types.isInt16Array(binaryLike) {
+        Int16Array(Obj.magic(binaryLike))
+      } else if Util.Types.isUint16Array(binaryLike) {
+        Uint16Array(Obj.magic(binaryLike))
+      } else if Util.Types.isInt32Array(binaryLike) {
+        Int32Array(Obj.magic(binaryLike))
+      } else if Util.Types.isUint32Array(binaryLike) {
+        Uint32Array(Obj.magic(binaryLike))
+      } else if Util.Types.isFloat32Array(binaryLike) {
+        Float32Array(Obj.magic(binaryLike))
+      } else if Util.Types.isFloat64Array(binaryLike) {
+        Float64Array(Obj.magic(binaryLike))
+      } else if Util.Types.isDataView(binaryLike) {
+        DataView(Obj.magic(binaryLike))
+      } else if Util.Types.isStringObject(binaryLike) {
+        String(Obj.magic(binaryLike))
+      } else {
+        Unknown(Obj.magic(binaryLike))
+      }
+    }
+}
+
+include Impl