@grain/stdlib 0.4.4 → 0.5.0

package/string.gr

@@ -9,7 +9,15 @@
 import WasmI32 from "runtime/unsafe/wasmi32"
 import Memory from "runtime/unsafe/memory"
 import Exception from "runtime/exception"
-import { tagSimpleNumber, allocateArray, allocateChar, allocateString, allocateBytes } from "runtime/dataStructures"
+import Conv from "runtime/unsafe/conv"
+import {
+  tagSimpleNumber,
+  tagChar,
+  untagChar,
+  allocateArray,
+  allocateString,
+  allocateBytes,
+} from "runtime/dataStructures"
 
 /**
  * @section Types: Type declarations included in the String module.
@@ -26,6 +34,8 @@ export enum Encoding {
   UTF32_LE,
 }
 
+exception MalformedUnicode
+
 /**
  * @section Values: Functions for working with the String data type.
  */
@@ -37,9 +47,9 @@ export enum Encoding {
  * @param str2: The ending string
  * @returns The combined string
  *
- * @example String.concat("Foo", " Bar") == "FooBar"
+ * @example String.concat("Foo", "Bar") == "FooBar"
  *
- * @since v0.1.0
+ * @since v0.2.0
  */
 export let concat = (++)
 
@@ -53,8 +63,8 @@ export let concat = (++)
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec length = (string: String) => {
+@unsafe
+export let length = (string: String) => {
   let string = WasmI32.fromGrain(string)
   let size = WasmI32.load(string, 4n)
 
@@ -70,18 +80,7 @@ export let rec length = (string: String) => {
     ptr = WasmI32.add(ptr, 1n)
   }
 
-  let ret = tagSimpleNumber(len)
-  Memory.decRef(WasmI32.fromGrain(length))
-  Memory.decRef(WasmI32.fromGrain(string))
-  ret
-}
-
-// @disableGC-safe wrapper
-@disableGC
-let wasmSafeLength = (s: String) => {
-  Memory.incRef(WasmI32.fromGrain(length))
-  Memory.incRef(WasmI32.fromGrain(s))
-  length(s)
+  Conv.wasmI32ToNumber(len)
 }
 
 /**
@@ -94,21 +93,10 @@ let wasmSafeLength = (s: String) => {
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec byteLength = (string: String) => {
+@unsafe
+export let byteLength = (string: String) => {
   let string = WasmI32.fromGrain(string)
-  let ret = tagSimpleNumber(WasmI32.load(string, 4n))
-  Memory.decRef(WasmI32.fromGrain(byteLength))
-  Memory.decRef(WasmI32.fromGrain(string))
-  ret
-}
-
-// @disableGC-safe wrapper
-@disableGC
-let wasmSafeByteLength = (string: String) => {
-  Memory.incRef(WasmI32.fromGrain(byteLength))
-  Memory.incRef(WasmI32.fromGrain(string))
-  byteLength(string)
+  Conv.wasmI32ToNumber(WasmI32.load(string, 4n))
 }
 
 /**
@@ -122,8 +110,8 @@ let wasmSafeByteLength = (string: String) => {
  *
  * @since v0.3.0
  */
-@disableGC
-export let rec indexOf = (search: String, string: String) => {
+@unsafe
+export let indexOf = (search: String, string: String) => {
   let search = WasmI32.fromGrain(search)
   let string = WasmI32.fromGrain(string)
 
@@ -137,10 +125,8 @@ export let rec indexOf = (search: String, string: String) => {
   let (-) = WasmI32.sub
   let (&) = WasmI32.and
 
-  let ret = if (psize > size) {
-    let none = None
-    Memory.incRef(WasmI32.fromGrain(none))
-    none
+  if (psize > size) {
+    None
   } else {
     let mut idx = 0n
     let mut ptr = string + 8n
@@ -168,20 +154,73 @@ export let rec indexOf = (search: String, string: String) => {
     }
 
     if (result == -1n) {
-      let none = None
-      Memory.incRef(WasmI32.fromGrain(none))
-      none
+      None
     } else {
-      Memory.incRef(WasmI32.fromGrain(Some))
       Some(tagSimpleNumber(result))
     }
   }
-  Memory.decRef(WasmI32.fromGrain(search))
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(indexOf))
-  ret
 }
 
+@disableGC
+let getCodePoint = (ptr: WasmI32) => {
+  // Algorithm from https://encoding.spec.whatwg.org/#utf-8-decoder
+  let (+) = WasmI32.add
+  let (==) = WasmI32.eq
+  let (>=) = WasmI32.geU
+  let (<=) = WasmI32.leU
+  let (<<) = WasmI32.shl
+  let (&) = WasmI32.and
+  let (|) = WasmI32.or
+
+  let mut codePoint = 0n
+  let mut bytesSeen = 0n
+  let mut bytesNeeded = 0n
+  let mut lowerBoundary = 0x80n
+  let mut upperBoundary = 0xBFn
+
+  let mut offset = 0n
+
+  let mut result = 0n
+
+  while (true) {
+    let byte = WasmI32.load8U(ptr + offset, 0n)
+    offset += 1n
+    if (bytesNeeded == 0n) {
+      if (byte >= 0x00n && byte <= 0x7Fn) {
+        result = byte
+        break
+      } else if (byte >= 0xC2n && byte <= 0xDFn) {
+        bytesNeeded = 1n
+        codePoint = byte & 0x1Fn
+      } else if (byte >= 0xE0n && byte <= 0xEFn) {
+        if (byte == 0xE0n) lowerBoundary = 0xA0n
+        if (byte == 0xEDn) upperBoundary = 0x9Fn
+        bytesNeeded = 2n
+        codePoint = byte & 0xFn
+      } else if (byte >= 0xF0n && byte <= 0xF4n) {
+        if (byte == 0xF0n) lowerBoundary = 0x90n
+        if (byte == 0xF4n) upperBoundary = 0x8Fn
+        bytesNeeded = 3n
+        codePoint = byte & 0x7n
+      } else {
+        throw MalformedUnicode
+      }
+      continue
+    }
+    if (!(lowerBoundary <= byte && byte <= upperBoundary)) {
+      throw MalformedUnicode
+    }
+    lowerBoundary = 0x80n
+    upperBoundary = 0xBFn
+    codePoint = codePoint << 6n | byte & 0x3Fn
+    bytesSeen += 1n
+    if (bytesSeen == bytesNeeded) {
+      result = codePoint
+      break
+    }
+  }
+  result
+}
 /**
  * Get the character at the position in the input string.
  *
@@ -193,13 +232,10 @@ export let rec indexOf = (search: String, string: String) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec charAt = (position, string: String) => {
-  Memory.incRef(WasmI32.fromGrain((<=)))
-  if (wasmSafeLength(string) <= position || {Memory.incRef(WasmI32.fromGrain((<))); position < 0}) {
-    Memory.incRef(WasmI32.fromGrain((++)))
-    Memory.incRef(WasmI32.fromGrain(toString))
-    fail ("Invalid offset: " ++ toString(position))
+@unsafe
+export let charAt = (position, string: String) => {
+  if (length(string) <= position || position < 0) {
+    fail "Invalid offset: " ++ toString(position)
   }
   // Implementation is similar to explodeHelp, but doesn't perform unneeded memory allocations
   let (>>>) = WasmI32.shrU
@@ -207,15 +243,18 @@ export let rec charAt = (position, string: String) => {
   let (&) = WasmI32.and
   let (<) = WasmI32.ltU
   let (==) = WasmI32.eq
-  let size = WasmI32.fromGrain(wasmSafeByteLength(string)) >>> 1n
-  let len = WasmI32.fromGrain(wasmSafeLength(string)) >>> 1n
+  let size = WasmI32.fromGrain(byteLength(string)) >>> 1n
   let position = WasmI32.fromGrain(position) >>> 1n
   let string = WasmI32.fromGrain(string)
-  let mut ptr = string + 8n;
-  let end = ptr + size;
-  let mut counter = 0n;
-  let mut result = 0n
+  let mut ptr = string + 8n
+  let end = ptr + size
+  let mut counter = 0n
+  let mut result = WasmI32.toGrain(0n): Char
   while (ptr < end) {
+    if (counter == position) {
+      result = tagChar(getCodePoint(ptr))
+      break
+    }
     let byte = WasmI32.load8U(ptr, 0n)
     let n = if ((byte & 0x80n) == 0x00n) {
       1n
@@ -226,25 +265,16 @@ export let rec charAt = (position, string: String) => {
     } else {
       2n
     }
-    if (counter == position) {
-      let c = allocateChar()
-      Memory.copy(c + 4n, ptr, n)
-      result = c
-      break
-    }
     counter += 1n
     ptr += n
   }
-  if (result == 0n) {
+  if (WasmI32.eqz(WasmI32.fromGrain(result))) {
     fail "charAt: should be impossible (please report)"
   }
-  let ret = WasmI32.toGrain(result): Char
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(charAt))
-  ret
+  result
 }
 
-@disableGC
+@unsafe
 let explodeHelp = (s: String, chars) => {
   let (>>>) = WasmI32.shrU
   let (+) = WasmI32.add
@@ -252,8 +282,8 @@ let explodeHelp = (s: String, chars) => {
   let (<) = WasmI32.ltU
   let (==) = WasmI32.eq
 
-  let size = WasmI32.fromGrain(wasmSafeByteLength(s)) >>> 1n
-  let len = WasmI32.fromGrain(wasmSafeLength(s)) >>> 1n
+  let size = WasmI32.fromGrain(byteLength(s)) >>> 1n
+  let len = WasmI32.fromGrain(length(s)) >>> 1n
 
   let s = WasmI32.fromGrain(s)
 
@@ -276,9 +306,7 @@ let explodeHelp = (s: String, chars) => {
     }
 
     let c = if (chars) {
-      let c = allocateChar()
-      Memory.copy(c + 4n, ptr, n)
-      c
+      WasmI32.fromGrain(tagChar(getCodePoint(ptr)))
     } else {
       let s = allocateString(n)
       Memory.copy(s + 8n, ptr, n)
@@ -303,15 +331,9 @@ let explodeHelp = (s: String, chars) => {
  *
  * @since v0.3.0
  */
-@disableGC
-export let rec explode = (string) => {
-  // `explodeHelp` and `string` do not need to be incRef'd as they are not
-  // decRef'd in `explodeHelp`
-  let ret = WasmI32.toGrain(explodeHelp(string, true)) : (Array<Char>)
-
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(explode))
-  ret
+@unsafe
+export let explode = string => {
+  WasmI32.toGrain(explodeHelp(string, true)): Array<Char>
 }
 
 /**
@@ -324,32 +346,34 @@ export let rec explode = (string) => {
  *
  * @since v0.3.0
  */
-@disableGC
-export let rec implode = (arr: Array<Char>) => {
+@unsafe
+export let implode = (arr: Array<Char>) => {
   let (+) = WasmI32.add
-  let (==) = WasmI32.eq
+  let (-) = WasmI32.sub
+  let (*) = WasmI32.mul
   let (<) = WasmI32.ltU
+  let (>) = WasmI32.gtU
+  let (<=) = WasmI32.leU
   let (<<) = WasmI32.shl
+  let (>>>) = WasmI32.shrU
   let (&) = WasmI32.and
+  let (|) = WasmI32.or
 
-  let arr = WasmI32.fromGrain(arr)
-
-  let arrLength = WasmI32.load(arr, 4n)
+  let arrLength = WasmI32.load(WasmI32.fromGrain(arr), 4n)
 
   let mut stringByteLength = 0n
 
   for (let mut i = 0n; i < arrLength; i += 1n) {
-    let char = WasmI32.load(arr + (i << 2n), 8n)
-    let byte = WasmI32.load8U(char, 4n)
+    let usv = untagChar(arr[tagSimpleNumber(i)])
 
-    let n = if ((byte & 0x80n) == 0x00n) {
+    let n = if (usv <= 0x7Fn) {
       1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
+    } else if (usv <= 0x07FFn) {
+      2n
+    } else if (usv <= 0xFFFFn) {
       3n
     } else {
-      2n
+      4n
     }
 
     stringByteLength += n
@@ -359,31 +383,41 @@ export let rec implode = (arr: Array<Char>) => {
   let mut offset = 8n
 
   for (let mut i = 0n; i < arrLength; i += 1n) {
-    let char = WasmI32.load(arr + (i << 2n), 8n)
-    let byte = WasmI32.load8U(char, 4n)
+    let usv = untagChar(arr[tagSimpleNumber(i)])
 
-    let n = if ((byte & 0x80n) == 0x00n) {
-      1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      3n
+    if (usv < 0x7Fn) {
+      WasmI32.store8(str + offset, usv, 0n)
+      offset += 1n
     } else {
-      2n
+      let mut count = 0n
+      let mut marker = 0n
+      if (usv <= 0x07FFn) {
+        count = 1n
+        marker = 0xC0n
+      } else if (usv <= 0xFFFFn) {
+        count = 2n
+        marker = 0xE0n
+      } else {
+        count = 3n
+        marker = 0xF0n
+      }
+      WasmI32.store8(str + offset, (usv >>> 6n * count) + marker, 0n)
+      offset += 1n
+
+      while (count > 0n) {
+        let temp = usv >>> 6n * (count - 1n)
+        WasmI32.store8(str + offset, 0x80n | temp & 0x3Fn, 0n)
+        count -= 1n
+        offset += 1n
+      }
     }
-
-    Memory.copy(str + offset, char + 4n, n)
-    offset += n
   }
 
-  let ret = WasmI32.toGrain(str): String
-  Memory.decRef(WasmI32.fromGrain(arr))
-  Memory.decRef(WasmI32.fromGrain(implode))
-  ret
+  WasmI32.toGrain(str): String
 }
 
 // Helper to get the length in constant time without depending on Array
-primitive arrayLength : Array<a> -> Number = "@array.length"
+primitive arrayLength: Array<a> -> Number = "@array.length"
 
 /**
  * Create a string that is the given string reversed.
@@ -395,7 +429,7 @@ primitive arrayLength : Array<a> -> Number = "@array.length"
  *
  * @since v0.4.5
  */
-export let reverse = (string) => {
+export let reverse = string => {
   let mut arr = explode(string)
   let len = arrayLength(arr)
   let halfLen = len / 2
@@ -418,8 +452,8 @@ export let reverse = (string) => {
  *
  * @example String.split(" ", "Hello world") == [> "Hello", "world"]
  */
-@disableGC
-export let rec split = (separator: String, string: String) => {
+@unsafe
+export let split = (separator: String, string: String) => {
   let (+) = WasmI32.add
   let (-) = WasmI32.sub
   let (==) = WasmI32.eq
@@ -429,16 +463,13 @@ export let rec split = (separator: String, string: String) => {
   let (>>) = WasmI32.shrS
   let (&) = WasmI32.and
 
-  let size = WasmI32.fromGrain(wasmSafeByteLength(string)) >> 1n
-  let psize = WasmI32.fromGrain(wasmSafeByteLength(separator)) >> 1n
+  let size = WasmI32.fromGrain(byteLength(string)) >> 1n
+  let psize = WasmI32.fromGrain(byteLength(separator)) >> 1n
 
-  let ret = if (psize == 0n) {
+  if (psize == 0n) {
     WasmI32.toGrain(explodeHelp(string, false)): Array<String>
   } else if (psize > size) {
-    let string = WasmI32.fromGrain(string)
-    let ptr = allocateArray(1n)
-    WasmI32.store(ptr, Memory.incRef(string), 8n)
-    WasmI32.toGrain(ptr): Array<String>
+    [> string]
   } else {
     let string = WasmI32.fromGrain(string)
     let separator = WasmI32.fromGrain(separator)
@@ -501,10 +532,6 @@ export let rec split = (separator: String, string: String) => {
 
     WasmI32.toGrain(arr): Array<String>
   }
-  Memory.decRef(WasmI32.fromGrain(separator))
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(split))
-  ret
 }
 
 /**
@@ -519,8 +546,8 @@ export let rec split = (separator: String, string: String) => {
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec slice = (start: Number, to: Number, string: String) => {
+@unsafe
+export let slice = (start: Number, to: Number, string: String) => {
   let (+) = WasmI32.add
   let (-) = WasmI32.sub
   let (==) = WasmI32.eq
@@ -533,8 +560,8 @@ export let rec slice = (start: Number, to: Number, string: String) => {
   let startOrig = start
   let toOrig = to
 
-  let len = WasmI32.fromGrain(wasmSafeLength(string)) >> 1n
-  let size = WasmI32.fromGrain(wasmSafeByteLength(string)) >> 1n
+  let len = WasmI32.fromGrain(length(string)) >> 1n
+  let size = WasmI32.fromGrain(byteLength(string)) >> 1n
 
   let string = WasmI32.fromGrain(string)
 
@@ -597,12 +624,7 @@ export let rec slice = (start: Number, to: Number, string: String) => {
 
   Memory.copy(newString + 8n, begin, newSize)
 
-  let ret = WasmI32.toGrain(newString): String
-  Memory.decRef(WasmI32.fromGrain(startOrig))
-  Memory.decRef(WasmI32.fromGrain(toOrig))
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(slice))
-  ret
+  WasmI32.toGrain(newString): String
 }
 
 /**
@@ -616,8 +638,8 @@ export let rec slice = (start: Number, to: Number, string: String) => {
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec contains = (search: String, string: String) => {
+@unsafe
+export let contains = (search: String, string: String) => {
   // "Not So Naive" string search algorithm
   // searching phase in O(nm) time complexity
   // slightly (by coefficient) sub-linear in the average case
@@ -634,8 +656,8 @@ export let rec contains = (search: String, string: String) => {
   let pOrig = search
   let sOrig = string
 
-  let n = WasmI32.fromGrain(wasmSafeByteLength(string)) >> 1n
-  let m = WasmI32.fromGrain(wasmSafeByteLength(search)) >> 1n
+  let n = WasmI32.fromGrain(byteLength(string)) >> 1n
+  let m = WasmI32.fromGrain(byteLength(search)) >> 1n
 
   let mut string = WasmI32.fromGrain(string)
   let mut search = WasmI32.fromGrain(search)
@@ -645,7 +667,7 @@ export let rec contains = (search: String, string: String) => {
 
   let mut j = 0n, k = 0n, ell = 0n
 
-  let ret = if (m > n) {
+  if (m > n) {
     // Bail if pattern length is longer than input length
     false
   } else if (m < 2n) {
@@ -681,7 +703,10 @@ export let rec contains = (search: String, string: String) => {
       if (WasmI32.load8U(search, 1n) != WasmI32.load8U(string + j, 1n)) {
         j += k
       } else {
-        if (Memory.compare(search + 2n, string + j + 2n, m - 2n) == 0n && WasmI32.load8U(search, 0n) == WasmI32.load8U(string + j, 0n)) {
+        if (
+          Memory.compare(search + 2n, string + j + 2n, m - 2n) == 0n &&
+          WasmI32.load8U(search, 0n) == WasmI32.load8U(string + j, 0n)
+        ) {
           result = true
           break
         }
@@ -690,10 +715,6 @@ export let rec contains = (search: String, string: String) => {
     }
     result
   }
-  Memory.decRef(WasmI32.fromGrain(pOrig))
-  Memory.decRef(WasmI32.fromGrain(sOrig))
-  Memory.decRef(WasmI32.fromGrain(contains))
-  ret
 }
 
 /**
@@ -707,8 +728,8 @@ export let rec contains = (search: String, string: String) => {
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec startsWith = (search: String, string: String) => {
+@unsafe
+export let startsWith = (search: String, string: String) => {
   let (+) = WasmI32.add
   let (>) = WasmI32.gtU
   let (==) = WasmI32.eq
@@ -725,15 +746,11 @@ export let rec startsWith = (search: String, string: String) => {
   search += 8n
 
   // Bail if pattern length is longer than input length
-  let ret = if (m > n) {
+  if (m > n) {
     false
   } else {
     Memory.compare(search, string, m) == 0n
   }
-  Memory.decRef(WasmI32.fromGrain(pOrig))
-  Memory.decRef(WasmI32.fromGrain(sOrig))
-  Memory.decRef(WasmI32.fromGrain(startsWith))
-  ret
 }
 
 /**
@@ -747,8 +764,8 @@ export let rec startsWith = (search: String, string: String) => {
  *
  * @since v0.1.0
  */
-@disableGC
-export let rec endsWith = (search: String, string: String) => {
+@unsafe
+export let endsWith = (search: String, string: String) => {
   let (+) = WasmI32.add
   let (-) = WasmI32.sub
   let (>) = WasmI32.gtU
@@ -766,15 +783,11 @@ export let rec endsWith = (search: String, string: String) => {
   search += 8n
 
   // Bail if pattern length is longer than input length
-  let ret = if (m > n) {
+  if (m > n) {
     false
   } else {
     Memory.compare(search, string + n - m, m) == 0n
   }
-  Memory.decRef(WasmI32.fromGrain(pOrig))
-  Memory.decRef(WasmI32.fromGrain(sOrig))
-  Memory.decRef(WasmI32.fromGrain(endsWith))
-  ret
 }
 
 // String->Byte encoding and helper functions:
@@ -784,30 +797,22 @@ let _START_NAME = "start"
 let _SIZE_NAME = "size"
 let _OFFSET_NAME = "offset"
 
-@disableGC
+@unsafe
 let grainToWasmNumber = (num, name) => {
   let num = WasmI32.fromGrain(num)
   if (WasmI32.eqz(WasmI32.and(num, 1n))) {
-    Memory.incRef(WasmI32.fromGrain(name))
-    Memory.incRef(WasmI32.fromGrain((++)))
     let str = " argument must be an integer"
-    Memory.incRef(WasmI32.fromGrain(str))
-    Memory.incRef(WasmI32.fromGrain(Exception.InvalidArgument))
     throw Exception.InvalidArgument(name ++ str)
   }
   let num = WasmI32.shrS(num, 1n)
   if (WasmI32.ltS(num, 0n)) {
-    Memory.incRef(WasmI32.fromGrain(name))
-    Memory.incRef(WasmI32.fromGrain((++)))
     let str = " argument must be non-negative"
-    Memory.incRef(WasmI32.fromGrain(str))
-    Memory.incRef(WasmI32.fromGrain(Exception.InvalidArgument))
     throw Exception.InvalidArgument(name ++ str)
   }
   num
 }
 
-@disableGC
+@unsafe
 let utf16Length = (s: String) => {
   let (>>>) = WasmI32.shrU
   let (<<) = WasmI32.shl
@@ -816,8 +821,8 @@ let utf16Length = (s: String) => {
   let (<) = WasmI32.ltU
   let (==) = WasmI32.eq
 
-  let size = WasmI32.fromGrain(wasmSafeByteLength(s)) >>> 1n
-  let len = WasmI32.fromGrain(wasmSafeLength(s)) >>> 1n
+  let size = WasmI32.fromGrain(byteLength(s)) >>> 1n
+  let len = WasmI32.fromGrain(length(s)) >>> 1n
 
   let s = WasmI32.fromGrain(s)
 
@@ -847,101 +852,31 @@ let utf16Length = (s: String) => {
   tagSimpleNumber(size << 1n)
 }
 
-@disableGC
+@unsafe
 let encodedLength = (s: String, encoding) => {
-  match(encoding) {
-    UTF32_BE => {
-      Memory.incRef(WasmI32.fromGrain((*)))
-      wasmSafeLength(s) * 4
-    },
-    UTF32_LE => {
-      Memory.incRef(WasmI32.fromGrain((*)))
-      wasmSafeLength(s) * 4
-    },
+  match (encoding) {
+    UTF32_BE => length(s) * 4,
+    UTF32_LE => length(s) * 4,
     UTF16_BE => utf16Length(s),
     UTF16_LE => utf16Length(s),
-    UTF8 => wasmSafeByteLength(s),
+    UTF8 => byteLength(s),
   }
 }
 
-exception MalformedUnicode
-
-@disableGC
-let getCodePoint = (ptr: WasmI32) => {
-  // Algorithm from https://encoding.spec.whatwg.org/#utf-8-decoder
-  let (+) = WasmI32.add
-  let (==) = WasmI32.eq
-  let (>=) = WasmI32.geU
-  let (<=) = WasmI32.leU
-  let (<<) = WasmI32.shl
-  let (&) = WasmI32.and
-  let (|) = WasmI32.or
-
-  let mut codePoint = 0n
-  let mut bytesSeen = 0n
-  let mut bytesNeeded = 0n
-  let mut lowerBoundary = 0x80n
-  let mut upperBoundary = 0xBFn
-
-  let mut offset = 0n
-
-  let mut result = 0n
-
-  while (true) {
-    let byte = WasmI32.load8U(ptr + offset, 0n)
-    offset += 1n
-    if (bytesNeeded == 0n) {
-      if (byte >= 0x00n && byte <= 0x7Fn) {
-        result = byte
-        break
-      } else if (byte >= 0xC2n && byte <= 0xDFn) {
-        bytesNeeded = 1n
-        codePoint = byte & 0x1Fn
-      } else if (byte >= 0xE0n && byte <= 0xEFn) {
-        if (byte == 0xE0n) lowerBoundary = 0xA0n
-        if (byte == 0xEDn) upperBoundary = 0x9Fn
-        bytesNeeded = 2n
-        codePoint = byte & 0xFn
-      } else if (byte >= 0xF0n && byte <= 0xF4n) {
-        if (byte == 0xF0n) lowerBoundary = 0x90n
-        if (byte == 0xF4n) upperBoundary = 0x8Fn
-        bytesNeeded = 3n
-        codePoint = byte & 0x7n
-      } else {
-        throw MalformedUnicode
-      }
-      continue
-    }
-    if (!(lowerBoundary <= byte && byte <= upperBoundary)) {
-      throw MalformedUnicode
-    }
-    lowerBoundary = 0x80n
-    upperBoundary = 0xBFn
-    codePoint = (codePoint << 6n) | (byte & 0x3Fn)
-    bytesSeen += 1n
-    if (bytesSeen == bytesNeeded) {
-      result = codePoint
-      break
-    }
-  }
-  result: WasmI32
-}
-
-// hack to avoid incRef on this pointer
-@disableGC
-let mut _BYTES_SIZE_OFFSET = 1n;
-@disableGC
-let mut _BYTES_OFFSET = 1n;
-
-@disableGC
-let initPtr = () => {
-  _BYTES_SIZE_OFFSET = 4n
-  _BYTES_OFFSET = 8n
-}
-initPtr();
-
-@disableGC
-let rec encodeAtHelp = (string: String, encoding: Encoding, includeBom: Bool, dest: Bytes, destPos: Number) => {
+@unsafe
+let mut _BYTES_SIZE_OFFSET = 4n
+@unsafe
+let mut _BYTES_OFFSET = 8n
+
+@unsafe
+let encodeAtHelp =
+  (
+    string: String,
+    encoding: Encoding,
+    includeBom: Bool,
+    dest: Bytes,
+    destPos: Number,
+  ) => {
   let (>>>) = WasmI32.shrU
   let (-) = WasmI32.sub
   let (&) = WasmI32.and
@@ -950,8 +885,8 @@ let rec encodeAtHelp = (string: String, encoding: Encoding, includeBom: Bool, de
   let (<=) = WasmI32.leU
   let (==) = WasmI32.eq
   let (+) = WasmI32.add
-  let byteSize = WasmI32.fromGrain(wasmSafeByteLength(string)) >>> 1n
-  let len = WasmI32.fromGrain(wasmSafeLength(string)) >>> 1n
+  let byteSize = WasmI32.fromGrain(byteLength(string)) >>> 1n
+  let len = WasmI32.fromGrain(length(string)) >>> 1n
 
   let string = WasmI32.fromGrain(string)
 
@@ -964,9 +899,9 @@ let rec encodeAtHelp = (string: String, encoding: Encoding, includeBom: Bool, de
   let destSize = WasmI32.load(bytes, _BYTES_SIZE_OFFSET)
 
   if (includeBom) {
-    match(encoding) {
+    match (encoding) {
       UTF8 => {
-        if ((bytesIdx + 3n) > destSize) {
+        if (bytesIdx + 3n > destSize) {
           throw Exception.IndexOutOfBounds
         }
         WasmI32.store8(bytes + bytesIdx, 0xEFn, _BYTES_OFFSET)
@@ -975,7 +910,7 @@ let rec encodeAtHelp = (string: String, encoding: Encoding, includeBom: Bool, de
         bytesIdx += 3n
       },
       UTF16_BE => {
-        if ((bytesIdx + 2n) > destSize) {
+        if (bytesIdx + 2n > destSize) {
           throw Exception.IndexOutOfBounds
         }
         WasmI32.store8(bytes + bytesIdx, 0xFEn, _BYTES_OFFSET)
@@ -983,7 +918,7 @@ let rec encodeAtHelp = (string: String, encoding: Encoding, includeBom: Bool, de
         bytesIdx += 2n
       },
       UTF16_LE => {
-        if ((bytesIdx + 2n) > destSize) {
+        if (bytesIdx + 2n > destSize) {
           throw Exception.IndexOutOfBounds
         }
         WasmI32.store8(bytes + bytesIdx, 0xFFn, _BYTES_OFFSET)
@@ -991,7 +926,7 @@ let rec encodeAtHelp = (string: String, encoding: Encoding, includeBom: Bool, de
         bytesIdx += 2n
       },
       UTF32_BE => {
-        if ((bytesIdx + 4n) > destSize) {
+        if (bytesIdx + 4n > destSize) {
           throw Exception.IndexOutOfBounds
         }
         WasmI32.store8(bytes + bytesIdx, 0n, _BYTES_OFFSET)
@@ -1001,7 +936,7 @@ let rec encodeAtHelp = (string: String, encoding: Encoding, includeBom: Bool, de
         bytesIdx += 4n
       },
       UTF32_LE => {
-        if ((bytesIdx + 4n) > destSize) {
+        if (bytesIdx + 4n > destSize) {
           throw Exception.IndexOutOfBounds
         }
         WasmI32.store8(bytes + bytesIdx, 0xFFn, _BYTES_OFFSET)
@@ -1009,16 +944,16 @@ let rec encodeAtHelp = (string: String, encoding: Encoding, includeBom: Bool, de
         WasmI32.store8(bytes + bytesIdx + 2n, 0n, _BYTES_OFFSET)
         WasmI32.store8(bytes + bytesIdx + 3n, 0n, _BYTES_OFFSET)
         bytesIdx += 4n
-      }
+      },
     }
   }
 
-  match(encoding) {
+  match (encoding) {
     UTF8 => {
       // Optimization: since internally strings in Grain are UTF8 encoded, when
       // the target encoding is UTF8 as well, then copy the entire memory range
       // in bulk. No need to iterate individual characters.
-      if ((bytesIdx + byteSize) > destSize) {
+      if (bytesIdx + byteSize > destSize) {
         throw Exception.IndexOutOfBounds
       }
       Memory.copy(bytes + bytesIdx + _BYTES_OFFSET, ptr, byteSize)
@@ -1036,37 +971,55 @@ let rec encodeAtHelp = (string: String, encoding: Encoding, includeBom: Bool, de
         } else {
           2n
         }
-        match(encoding) {
+        match (encoding) {
           UTF8 => {
             // With the optimization above for bulk memory copy, this match
             // should never occur for the UTF8 case.
-            if ((bytesIdx + n) > destSize) {
+            if (bytesIdx + n > destSize) {
               throw Exception.IndexOutOfBounds
             }
-            Memory.copy(bytes + bytesIdx + _BYTES_OFFSET, ptr, n);
+            Memory.copy(bytes + bytesIdx + _BYTES_OFFSET, ptr, n)
             bytesIdx += n
           },
           UTF16_BE => {
             let codePoint = getCodePoint(ptr)
             if (codePoint <= 0xFFFFn) {
               // <hi><lo>
-              if ((bytesIdx + 2n) > destSize) {
+              if (bytesIdx + 2n > destSize) {
                 throw Exception.IndexOutOfBounds
               }
-              WasmI32.store8(bytes + bytesIdx, (codePoint & 0xff00n) >>> 8n, _BYTES_OFFSET)
-              WasmI32.store8(bytes + bytesIdx + 1n, codePoint & 0xffn, _BYTES_OFFSET)
+              WasmI32.store8(
+                bytes + bytesIdx,
+                (codePoint & 0xff00n) >>> 8n,
+                _BYTES_OFFSET
+              )
+              WasmI32.store8(
+                bytes + bytesIdx + 1n,
+                codePoint & 0xffn,
+                _BYTES_OFFSET
+              )
               bytesIdx += 2n
             } else {
               // https://en.wikipedia.org/wiki/UTF-16#Code_points_from_U+010000_to_U+10FFFF
-              if ((bytesIdx + 4n) > destSize) {
+              if (bytesIdx + 4n > destSize) {
                 throw Exception.IndexOutOfBounds
               }
               let uPrime = codePoint - 0x10000n
-              let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) + 0xD800n // High surrogate
-              let w2 = (uPrime & 0b00000000001111111111n) + 0xDC00n // Low surrogate
-              WasmI32.store8(bytes + bytesIdx, (w1 & 0xff00n) >>> 8n, _BYTES_OFFSET)
+              let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) +
+                0xD800n // High surrogate
+              let w2 = (uPrime & 0b00000000001111111111n) +
+                0xDC00n // Low surrogate
+              WasmI32.store8(
+                bytes + bytesIdx,
+                (w1 & 0xff00n) >>> 8n,
+                _BYTES_OFFSET
+              )
               WasmI32.store8(bytes + bytesIdx + 1n, w1 & 0xffn, _BYTES_OFFSET)
-              WasmI32.store8(bytes + bytesIdx + 2n, (w2 & 0xff00n) >>> 8n, _BYTES_OFFSET)
+              WasmI32.store8(
+                bytes + bytesIdx + 2n,
+                (w2 & 0xff00n) >>> 8n,
+                _BYTES_OFFSET
+              )
               WasmI32.store8(bytes + bytesIdx + 3n, w2 & 0xffn, _BYTES_OFFSET)
               bytesIdx += 4n
             }
@@ -1074,63 +1027,98 @@ let rec encodeAtHelp = (string: String, encoding: Encoding, includeBom: Bool, de
           UTF16_LE => {
             let codePoint = getCodePoint(ptr)
             if (codePoint <= 0xFFFFn) {
-              if ((bytesIdx + 2n) > destSize) {
+              if (bytesIdx + 2n > destSize) {
                 throw Exception.IndexOutOfBounds
               }
               // <lo><hi>
               WasmI32.store8(bytes + bytesIdx, codePoint & 0xffn, _BYTES_OFFSET)
-              WasmI32.store8(bytes + bytesIdx + 1n, (codePoint & 0xff00n) >>> 8n, _BYTES_OFFSET)
+              WasmI32.store8(
+                bytes + bytesIdx + 1n,
+                (codePoint & 0xff00n) >>> 8n,
+                _BYTES_OFFSET
+              )
               bytesIdx += 2n
             } else {
               // https://en.wikipedia.org/wiki/UTF-16#Code_points_from_U+010000_to_U+10FFFF
-              if ((bytesIdx + 4n) > destSize) {
+              if (bytesIdx + 4n > destSize) {
                 throw Exception.IndexOutOfBounds
               }
               let uPrime = codePoint - 0x10000n
-              let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) + 0xD800n // High surrogate
-              let w2 = (uPrime & 0b00000000001111111111n) + 0xDC00n // Low surrogate
+              let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) +
+                0xD800n // High surrogate
+              let w2 = (uPrime & 0b00000000001111111111n) +
+                0xDC00n // Low surrogate
               WasmI32.store8(bytes + bytesIdx, w1 & 0xffn, _BYTES_OFFSET)
-              WasmI32.store8(bytes + bytesIdx + 1n, (w1 & 0xff00n) >>> 8n, _BYTES_OFFSET)
+              WasmI32.store8(
+                bytes + bytesIdx + 1n,
+                (w1 & 0xff00n) >>> 8n,
+                _BYTES_OFFSET
+              )
               WasmI32.store8(bytes + bytesIdx + 2n, w2 & 0xffn, _BYTES_OFFSET)
-              WasmI32.store8(bytes + bytesIdx + 3n, (w2 & 0xff00n) >>> 8n, _BYTES_OFFSET)
+              WasmI32.store8(
+                bytes + bytesIdx + 3n,
+                (w2 & 0xff00n) >>> 8n,
+                _BYTES_OFFSET
+              )
               bytesIdx += 4n
             }
           },
           UTF32_BE => {
-            if ((bytesIdx + 4n) > destSize) {
+            if (bytesIdx + 4n > destSize) {
               throw Exception.IndexOutOfBounds
             }
             let codePoint = getCodePoint(ptr)
-            WasmI32.store8(bytes + bytesIdx, (codePoint & 0xff000000n) >>> 24n, _BYTES_OFFSET)
-            WasmI32.store8(bytes + bytesIdx + 1n, (codePoint & 0xff0000n) >>> 16n, _BYTES_OFFSET)
-            WasmI32.store8(bytes + bytesIdx + 2n, (codePoint & 0xff00n) >>> 8n, _BYTES_OFFSET)
-            WasmI32.store8(bytes + bytesIdx + 3n, codePoint & 0xffn, _BYTES_OFFSET)
+            WasmI32.store8(
+              bytes + bytesIdx,
+              (codePoint & 0xff000000n) >>> 24n,
+              _BYTES_OFFSET
+            )
+            WasmI32.store8(
+              bytes + bytesIdx + 1n,
+              (codePoint & 0xff0000n) >>> 16n,
+              _BYTES_OFFSET
+            )
+            WasmI32.store8(
+              bytes + bytesIdx + 2n,
+              (codePoint & 0xff00n) >>> 8n,
+              _BYTES_OFFSET
+            )
+            WasmI32.store8(
+              bytes + bytesIdx + 3n,
+              codePoint & 0xffn,
+              _BYTES_OFFSET
+            )
             bytesIdx += 4n
           },
           UTF32_LE => {
-            if ((bytesIdx + 4n) > destSize) {
+            if (bytesIdx + 4n > destSize) {
               throw Exception.IndexOutOfBounds
             }
             let codePoint = getCodePoint(ptr)
             WasmI32.store8(bytes + bytesIdx, codePoint & 0xffn, _BYTES_OFFSET)
-            WasmI32.store8(bytes + bytesIdx + 1n, (codePoint & 0xff00n) >>> 8n, _BYTES_OFFSET)
-            WasmI32.store8(bytes + bytesIdx + 2n, (codePoint & 0xff0000n) >>> 16n, _BYTES_OFFSET)
-            WasmI32.store8(bytes + bytesIdx + 3n, (codePoint & 0xff000000n) >>> 24n, _BYTES_OFFSET)
+            WasmI32.store8(
+              bytes + bytesIdx + 1n,
+              (codePoint & 0xff00n) >>> 8n,
+              _BYTES_OFFSET
+            )
+            WasmI32.store8(
+              bytes + bytesIdx + 2n,
+              (codePoint & 0xff0000n) >>> 16n,
+              _BYTES_OFFSET
+            )
+            WasmI32.store8(
+              bytes + bytesIdx + 3n,
+              (codePoint & 0xff000000n) >>> 24n,
+              _BYTES_OFFSET
+            )
             bytesIdx += 4n
           },
-        };
+        }
         ptr += n
       }
-    }
+    },
   }
 
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(encoding))
-  Memory.decRef(WasmI32.fromGrain(includeBom))
-  Memory.decRef(WasmI32.fromGrain(destPos))
-  Memory.decRef(WasmI32.fromGrain(encodeAtHelp))
-
-  // We don't decRef `dest` because we're returning it
   dest
 }
 
@@ -1164,31 +1152,23 @@ export let encodeAtWithBom = (string, encoding, dest, destPos) => {
   encodeAtHelp(string, encoding, true, dest, destPos)
 }
 
-@disableGC
-let rec encodeHelp = (string: String, encoding: Encoding, includeBom: Bool) => {
-  Memory.incRef(WasmI32.fromGrain((+)))
-  let size = encodedLength(string, encoding) + if (includeBom) {
-    match(encoding) {
-      UTF8 => 3,
-      UTF16_LE => 2,
-      UTF16_BE => 2,
-      UTF32_LE => 4,
-      UTF32_BE => 4,
-    }
-  } else 0
+@unsafe
+let encodeHelp = (string: String, encoding: Encoding, includeBom: Bool) => {
+  let size = encodedLength(string, encoding) +
+    (if (includeBom) {
+      match (encoding) {
+        UTF8 => 3,
+        UTF16_LE => 2,
+        UTF16_BE => 2,
+        UTF32_LE => 4,
+        UTF32_BE => 4,
+      }
+    } else {
+      0
+    })
   let (>>>) = WasmI32.shrU
   let bytes = WasmI32.toGrain(allocateBytes(WasmI32.fromGrain(size) >>> 1n))
-  Memory.incRef(WasmI32.fromGrain(encodeAtHelp))
-  Memory.incRef(WasmI32.fromGrain(string))
-  Memory.incRef(WasmI32.fromGrain(encoding))
-  Memory.incRef(WasmI32.fromGrain(includeBom))
-  Memory.incRef(WasmI32.fromGrain(bytes))
-  let ret = encodeAtHelp(string, encoding, includeBom, bytes, 0)
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(encoding))
-  Memory.decRef(WasmI32.fromGrain(includeBom))
-  Memory.decRef(WasmI32.fromGrain(encodeHelp))
-  ret
+  encodeAtHelp(string, encoding, includeBom, bytes, 0)
 }
 
 /**
@@ -1219,7 +1199,7 @@ export let encodeWithBom = (string: String, encoding: Encoding) => {
 
 // Byte->String decoding and helper functions:
 
-@disableGC
+@unsafe
 let writeUtf8CodePoint = (ptr, codePoint) => {
   let (>>>) = WasmI32.shrU
   let (-) = WasmI32.sub
@@ -1242,8 +1222,8 @@ let writeUtf8CodePoint = (ptr, codePoint) => {
     // The first byte has a three bit prefix of 110, followed by 5 bits of the
     // codepoint. The second byte has a two bit prefix of 10, followed by 6 bits
     // of the codepoint.
-    let high = ((codePoint >>> 6n) & 0b000_11111n) | 0b110_00000n
-    let low =  ( codePoint         & 0b00_111111n) | 0b10_000000n
+    let high = codePoint >>> 6n & 0b000_11111n | 0b110_00000n
+    let low = codePoint & 0b00_111111n | 0b10_000000n
     WasmI32.store8(ptr, high, 0n)
     WasmI32.store8(ptr + 1n, low, 0n)
     2n
@@ -1252,9 +1232,9 @@ let writeUtf8CodePoint = (ptr, codePoint) => {
     // The first byte has a four bit prefix of 1110, followed by 4 bits of the
     // codepoint. Remaining bytes each have a two bit prefix of 10, followed by
     // 6 bits of the codepoint.
-    let high = ((codePoint >>> 12n) & 0b0000_1111n) | 0b1110_0000n
-    let mid =  ((codePoint >>> 6n)  & 0b00_111111n) | 0b10_000000n
-    let low =  ( codePoint          & 0b00_111111n) | 0b10_000000n
+    let high = codePoint >>> 12n & 0b0000_1111n | 0b1110_0000n
+    let mid = codePoint >>> 6n & 0b00_111111n | 0b10_000000n
+    let low = codePoint & 0b00_111111n | 0b10_000000n
     WasmI32.store8(ptr, high, 0n)
     WasmI32.store8(ptr + 1n, mid, 0n)
     WasmI32.store8(ptr + 2n, low, 0n)
@@ -1264,10 +1244,10 @@ let writeUtf8CodePoint = (ptr, codePoint) => {
     // The first byte has a five bit prefix of 11110, followed by 3 bits of the
     // codepoint. Remaining bytes each have a two bit prefix of 10, followed by
     // 6 bits of the codepoint.
-    let high = ((codePoint >>> 18n) & 0b00000_111n) | 0b11110_000n
-    let mid1 = ((codePoint >>> 12n) & 0b00_111111n) | 0b10_000000n
-    let mid2 = ((codePoint >>> 6n)  & 0b00_111111n) | 0b10_000000n
-    let low =  ( codePoint          & 0b00_111111n) | 0b10_000000n
+    let high = codePoint >>> 18n & 0b00000_111n | 0b11110_000n
+    let mid1 = codePoint >>> 12n & 0b00_111111n | 0b10_000000n
+    let mid2 = codePoint >>> 6n & 0b00_111111n | 0b10_000000n
+    let low = codePoint & 0b00_111111n | 0b10_000000n
     WasmI32.store8(ptr, high, 0n)
     WasmI32.store8(ptr + 1n, mid1, 0n)
     WasmI32.store8(ptr + 2n, mid2, 0n)
@@ -1276,7 +1256,7 @@ let writeUtf8CodePoint = (ptr, codePoint) => {
   }
 }
 
-@disableGC
+@unsafe
 let bytesHaveBom = (bytes: Bytes, encoding: Encoding, start: WasmI32) => {
   let (+) = WasmI32.add
   let (==) = WasmI32.eq
@@ -1286,25 +1266,46 @@ let bytesHaveBom = (bytes: Bytes, encoding: Encoding, start: WasmI32) => {
   let ptr = ptr + start
   match (encoding) {
     UTF8 => {
-      bytesSize >= 3n && WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xEFn && WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xBBn && WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0xBFn
+      bytesSize >= 3n &&
+      WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xEFn &&
+      WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xBBn &&
+      WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0xBFn
     },
     UTF16_BE => {
-      bytesSize >= 2n && WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFEn && WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFFn
+      bytesSize >= 2n &&
+      WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFEn &&
+      WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFFn
     },
     UTF16_LE => {
-      bytesSize >= 2n && WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFFn && WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFEn
+      bytesSize >= 2n &&
+      WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFFn &&
+      WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFEn
     },
     UTF32_BE => {
-      bytesSize >= 4n && WasmI32.load8U(ptr, _BYTES_OFFSET) == 0x00n  && WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0x00n && WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0xFEn && WasmI32.load8U(ptr + 3n, _BYTES_OFFSET) == 0xFFn
+      bytesSize >= 4n &&
+      WasmI32.load8U(ptr, _BYTES_OFFSET) == 0x00n &&
+      WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0x00n &&
+      WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0xFEn &&
+      WasmI32.load8U(ptr + 3n, _BYTES_OFFSET) == 0xFFn
     },
     UTF32_LE => {
-      bytesSize >= 4n && WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFFn && WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFEn && WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0x00n  && WasmI32.load8U(ptr + 3n, _BYTES_OFFSET) == 0x00n
-    }
+      bytesSize >= 4n &&
+      WasmI32.load8U(ptr, _BYTES_OFFSET) == 0xFFn &&
+      WasmI32.load8U(ptr + 1n, _BYTES_OFFSET) == 0xFEn &&
+      WasmI32.load8U(ptr + 2n, _BYTES_OFFSET) == 0x00n &&
+      WasmI32.load8U(ptr + 3n, _BYTES_OFFSET) == 0x00n
+    },
   }
 }
 
-@disableGC
-let decodedLength = (bytes: Bytes, encoding: Encoding, start: WasmI32, size: WasmI32) => {
+@unsafe
+let decodedLength =
+  (
+    bytes: Bytes,
+    encoding: Encoding,
+    start: WasmI32,
+    size: WasmI32,
+  ) => {
   let (+) = WasmI32.add
   let (-) = WasmI32.sub
   let (==) = WasmI32.eq
@@ -1327,20 +1328,21 @@ let decodedLength = (bytes: Bytes, encoding: Encoding, start: WasmI32, size: Was
     }
   }
   let start = ptr + _BYTES_OFFSET + start
-  match(encoding) {
+  match (encoding) {
     UTF8 => bytesSize,
     UTF16_BE => {
       let end = start + bytesSize
       let mut ptr = start
       let mut count = 0n
       while (ptr < end) {
-        let codeWord = (WasmI32.load8U(ptr, 0n) << 8n) | (WasmI32.load8U(ptr, 1n))
+        let codeWord = WasmI32.load8U(ptr, 0n) << 8n | WasmI32.load8U(ptr, 1n)
         let codeWord = if (codeWord >= 0xD800n && codeWord <= 0xDBFFn) {
           // high surrogate. need to check that next character is low srurrogate
           let ret = if (ptr + 2n >= end) {
             throw MalformedUnicode
           } else {
-            let nextCodeWord = (WasmI32.load8U(ptr, 2n) << 8n) | (WasmI32.load8U(ptr, 3n))
+            let nextCodeWord = WasmI32.load8U(ptr, 2n) << 8n |
+              WasmI32.load8U(ptr, 3n)
             if (nextCodeWord < 0xDC00n || nextCodeWord > 0xDFFFn) {
               // high surrogate without low surrogate
               throw MalformedUnicode
@@ -1374,13 +1376,14 @@ let decodedLength = (bytes: Bytes, encoding: Encoding, start: WasmI32, size: Was
       let mut ptr = start
       let mut count = 0n
       while (ptr < end) {
-        let codeWord = (WasmI32.load8U(ptr, 1n) << 8n) | (WasmI32.load8U(ptr, 0n))
+        let codeWord = WasmI32.load8U(ptr, 1n) << 8n | WasmI32.load8U(ptr, 0n)
         let codeWord = if (codeWord >= 0xD800n && codeWord <= 0xDBFFn) {
           // high surrogate. need to check that next character is low srurrogate
           let ret = if (ptr + 2n >= end) {
             throw MalformedUnicode
           } else {
-            let nextCodeWord = (WasmI32.load8U(ptr, 3n) << 8n) | (WasmI32.load8U(ptr, 2n))
+            let nextCodeWord = WasmI32.load8U(ptr, 3n) << 8n |
+              WasmI32.load8U(ptr, 2n)
             if (nextCodeWord < 0xDC00n || nextCodeWord > 0xDFFFn) {
               // high surrogate without low surrogate
               throw MalformedUnicode
@@ -1418,7 +1421,10 @@ let decodedLength = (bytes: Bytes, encoding: Encoding, start: WasmI32, size: Was
       let mut ptr = start
       let mut count = 0n
       while (ptr < end) {
-        let codeWord = (WasmI32.load8U(ptr, 0n) << 24n) | (WasmI32.load8U(ptr, 1n) << 16n) | (WasmI32.load8U(ptr, 2n) << 8n) | (WasmI32.load8U(ptr, 3n))
+        let codeWord = WasmI32.load8U(ptr, 0n) << 24n |
+          WasmI32.load8U(ptr, 1n) << 16n |
+          WasmI32.load8U(ptr, 2n) << 8n |
+          WasmI32.load8U(ptr, 3n)
         ptr += 4n
         if (codeWord <= 0x007Fn) {
           count += 1n
@@ -1441,7 +1447,10 @@ let decodedLength = (bytes: Bytes, encoding: Encoding, start: WasmI32, size: Was
       let mut ptr = start
       let mut count = 0n
       while (ptr < end) {
-        let codeWord = (WasmI32.load8U(ptr, 3n) << 24n) | (WasmI32.load8U(ptr, 2n) << 16n) | (WasmI32.load8U(ptr, 1n) << 8n) | (WasmI32.load8U(ptr, 0n))
+        let codeWord = WasmI32.load8U(ptr, 3n) << 24n |
+          WasmI32.load8U(ptr, 2n) << 16n |
+          WasmI32.load8U(ptr, 1n) << 8n |
+          WasmI32.load8U(ptr, 0n)
         ptr += 4n
         if (codeWord <= 0x007Fn) {
           count += 1n
@@ -1454,12 +1463,19 @@ let decodedLength = (bytes: Bytes, encoding: Encoding, start: WasmI32, size: Was
         }
       }
       count
-    }
+    },
   }
 }
 
-@disableGC
-let rec decodeRangeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool, start: Number, size: Number) => {
+@unsafe
+let decodeRangeHelp =
+  (
+    bytes: Bytes,
+    encoding: Encoding,
+    skipBom: Bool,
+    start: Number,
+    size: Number,
+  ) => {
   let (+) = WasmI32.add
   let (-) = WasmI32.sub
   let (<) = WasmI32.ltU
@@ -1474,7 +1490,7 @@ let rec decodeRangeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool, star
   let size = grainToWasmNumber(size, _SIZE_NAME)
   let hasBom = bytesHaveBom(bytes, encoding, start)
   let stringSize = decodedLength(bytes, encoding, start, size)
-  let stringSize = if (skipBom && hasBom) (stringSize - 3n) else stringSize
+  let stringSize = if (skipBom && hasBom) stringSize - 3n else stringSize
   let str = allocateString(stringSize)
   let mut bytesPtr = WasmI32.fromGrain(bytes)
   let bytesSize = {
@@ -1489,7 +1505,7 @@ let rec decodeRangeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool, star
   let mut strPtr = str + 8n
   let mut bomRead = false
   if (skipBom && hasBom) {
-    bytesPtr += match(encoding) {
+    bytesPtr += match (encoding) {
       UTF8 => 3n,
       UTF16_LE => 2n,
       UTF16_BE => 2n,
@@ -1497,10 +1513,10 @@ let rec decodeRangeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool, star
       UTF32_BE => 4n,
     }
   }
-  let ret = if (stringSize == 0n) {
-    WasmI32.toGrain(str) : String
+  if (stringSize == 0n) {
+    WasmI32.toGrain(str): String
   } else {
-    match(encoding) {
+    match (encoding) {
       UTF8 => {
         Memory.copy(strPtr, bytesPtr, stringSize)
       },
@@ -1508,11 +1524,14 @@ let rec decodeRangeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool, star
         // NOTE: Because the size check passed, we know the string is well-formed
         let end = bytesPtr + bytesSize
         while (bytesPtr < end) {
-          let w1 = (WasmI32.load8U(bytesPtr, 0n) << 8n) | (WasmI32.load8U(bytesPtr, 1n))
+          let w1 = WasmI32.load8U(bytesPtr, 0n) << 8n |
+            WasmI32.load8U(bytesPtr, 1n)
           let codeWord = if (w1 >= 0xD800n && w1 <= 0xDBFFn) {
             // high surrogate. next character is low srurrogate
             let w1 = (w1 & 0x03FFn) << 10n
-            let w2 = ((WasmI32.load8U(bytesPtr, 2n) << 8n) | (WasmI32.load8U(bytesPtr, 3n))) & 0x03FFn
+            let w2 = (WasmI32.load8U(bytesPtr, 2n) << 8n |
+                WasmI32.load8U(bytesPtr, 3n)) &
+              0x03FFn
             let codeWord = w1 + w2 + 0x10000n
             // no problems, so go past both code words
             bytesPtr += 4n
@@ -1528,11 +1547,14 @@ let rec decodeRangeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool, star
         // NOTE: Because the size check passed, we know the string is well-formed
         let end = bytesPtr + bytesSize
         while (bytesPtr < end) {
-          let w1 = (WasmI32.load8U(bytesPtr, 1n) << 8n) | (WasmI32.load8U(bytesPtr, 0n))
+          let w1 = WasmI32.load8U(bytesPtr, 1n) << 8n |
+            WasmI32.load8U(bytesPtr, 0n)
           let codeWord = if (w1 >= 0xD800n && w1 <= 0xDBFFn) {
             // high surrogate. next character is low srurrogate
             let w1 = (w1 & 0x03FFn) << 10n
-            let w2 = ((WasmI32.load8U(bytesPtr, 3n) << 8n) | (WasmI32.load8U(bytesPtr, 2n))) & 0x03FFn
+            let w2 = (WasmI32.load8U(bytesPtr, 3n) << 8n |
+                WasmI32.load8U(bytesPtr, 2n)) &
+              0x03FFn
             //let uPrime = codePoint - 0x10000n
             //let w1 = ((uPrime & 0b11111111110000000000n) >>> 10n) + 0xD800n // High surrogate
             //let w2 = (uPrime & 0b00000000001111111111n) + 0xDC00n // Low surrogate
@@ -1550,7 +1572,10 @@ let rec decodeRangeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool, star
       UTF32_BE => {
         let end = bytesPtr + bytesSize
         while (bytesPtr < end) {
-          let codeWord = (WasmI32.load8U(bytesPtr, 0n) << 24n) | (WasmI32.load8U(bytesPtr, 1n) << 16n) | (WasmI32.load8U(bytesPtr, 2n) << 8n) | (WasmI32.load8U(bytesPtr, 3n))
+          let codeWord = WasmI32.load8U(bytesPtr, 0n) << 24n |
+            WasmI32.load8U(bytesPtr, 1n) << 16n |
+            WasmI32.load8U(bytesPtr, 2n) << 8n |
+            WasmI32.load8U(bytesPtr, 3n)
           bytesPtr += 4n
           strPtr += writeUtf8CodePoint(strPtr, codeWord)
         }
@@ -1558,20 +1583,17 @@ let rec decodeRangeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool, star
       UTF32_LE => {
         let end = bytesPtr + bytesSize
         while (bytesPtr < end) {
-          let codeWord = (WasmI32.load8U(bytesPtr, 3n) << 24n) | (WasmI32.load8U(bytesPtr, 2n) << 16n) | (WasmI32.load8U(bytesPtr, 1n) << 8n) | (WasmI32.load8U(bytesPtr, 0n))
+          let codeWord = WasmI32.load8U(bytesPtr, 3n) << 24n |
+            WasmI32.load8U(bytesPtr, 2n) << 16n |
+            WasmI32.load8U(bytesPtr, 1n) << 8n |
+            WasmI32.load8U(bytesPtr, 0n)
           bytesPtr += 4n
           strPtr += writeUtf8CodePoint(strPtr, codeWord)
         }
-      }
+      },
     }
-    WasmI32.toGrain(str) : String
+    WasmI32.toGrain(str): String
   }
-  // bytes: Bytes, encoding: Encoding, skipBom: Bool, start: Number, size: Number
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(encoding))
-  Memory.decRef(WasmI32.fromGrain(skipBom))
-  Memory.decRef(WasmI32.fromGrain(decodeRangeHelp))
-  ret
 }
 
 /**
@@ -1585,7 +1607,13 @@ let rec decodeRangeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool, star
  *
  * @since v0.4.0
  */
-export let decodeRange = (bytes: Bytes, encoding: Encoding, start: Number, size: Number) => {
+export let decodeRange =
+  (
+    bytes: Bytes,
+    encoding: Encoding,
+    start: Number,
+    size: Number,
+  ) => {
   decodeRangeHelp(bytes, encoding, true, start, size)
 }
 
@@ -1600,22 +1628,21 @@ export let decodeRange = (bytes: Bytes, encoding: Encoding, start: Number, size:
  *
  * @since v0.4.0
  */
-export let decodeRangeKeepBom = (bytes: Bytes, encoding: Encoding, start: Number, size: Number) => {
+export let decodeRangeKeepBom =
+  (
+    bytes: Bytes,
+    encoding: Encoding,
+    start: Number,
+    size: Number,
+  ) => {
   decodeRangeHelp(bytes, encoding, false, start, size)
 }
 
-@disableGC
-let rec decodeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool) => {
+@unsafe
+let decodeHelp = (bytes: Bytes, encoding: Encoding, skipBom: Bool) => {
   let bytesPtr = WasmI32.fromGrain(bytes)
   let bytesSize = WasmI32.load(bytesPtr, 4n)
-  Memory.incRef(WasmI32.fromGrain(decodeRangeHelp))
-  Memory.incRef(WasmI32.fromGrain(bytes))
-  Memory.incRef(WasmI32.fromGrain(encoding))
-  let ret = decodeRangeHelp(bytes, encoding, skipBom, 0, tagSimpleNumber(bytesSize))
-  Memory.incRef(WasmI32.fromGrain(bytes))
-  Memory.incRef(WasmI32.fromGrain(encoding))
-  Memory.incRef(WasmI32.fromGrain(decodeHelp))
-  ret
+  decodeRangeHelp(bytes, encoding, skipBom, 0, tagSimpleNumber(bytesSize))
 }
 
 /**
@@ -1654,8 +1681,8 @@ export let decodeKeepBom = (bytes: Bytes, encoding: Encoding) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec forEachCodePoint = (fn: (Number) -> Void, str: String) => {
+@unsafe
+export let forEachCodePoint = (fn: Number -> Void, str: String) => {
   let (>>>) = WasmI32.shrU
   let (-) = WasmI32.sub
   let (&) = WasmI32.and
@@ -1692,15 +1719,11 @@ export let rec forEachCodePoint = (fn: (Number) -> Void, str: String) => {
     // avoid heap allocations. `getCodePoint` will throw
     // MalformedUnicode exception for values exceeding this limit.
     let codePoint = getCodePoint(ptr)
-    Memory.incRef(WasmI32.fromGrain(fn))
     fn(tagSimpleNumber(codePoint))
 
     ptr += codePointByteCount
     idx += 1n
   }
-  Memory.decRef(WasmI32.fromGrain(fn))
-  Memory.decRef(WasmI32.fromGrain(str))
-  Memory.decRef(WasmI32.fromGrain(forEachCodePoint))
   void
 }
 
@@ -1716,8 +1739,8 @@ export let rec forEachCodePoint = (fn: (Number) -> Void, str: String) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec forEachCodePointi = (fn: (Number, Number) -> Void, str: String) => {
+@unsafe
+export let forEachCodePointi = (fn: (Number, Number) -> Void, str: String) => {
   let (>>>) = WasmI32.shrU
   let (-) = WasmI32.sub
   let (&) = WasmI32.and
@@ -1754,42 +1777,38 @@ export let rec forEachCodePointi = (fn: (Number, Number) -> Void, str: String) =
     // avoid heap allocations. `getCodePoint` will throw
     // MalformedUnicode exception for values exceeding this limit.
     let codePoint = getCodePoint(ptr)
-    Memory.incRef(WasmI32.fromGrain(fn))
     fn(tagSimpleNumber(codePoint), tagSimpleNumber(idx))
 
     ptr += codePointByteCount
     idx += 1n
   }
-  Memory.decRef(WasmI32.fromGrain(fn))
-  Memory.decRef(WasmI32.fromGrain(str))
-  Memory.decRef(WasmI32.fromGrain(forEachCodePointi))
   void
 }
+
 let trimString = (str: String, end: Bool) => {
   let chars = explode(str), charsLength = length(str)
   let mut i = 0, offset = 1
   if (end) {
-    i = charsLength-1
+    i = charsLength - 1
     offset = -1
   }
   for (; i < charsLength && i > -1; i += offset) {
-    let currentChar = chars[i];
+    let currentChar = chars[i]
     // TODO: Use unicode whitespace property and unicode line terminator once github issue #661 is completed
     if (
       // Spacing
-      currentChar != '\u{0009}'  && // Tab
-      currentChar != '\u{000B}'  && // LINE TABULATION
-      currentChar != '\u{000C}'  && // FORM FEED (FF)
-      currentChar != '\u{0020}'  && // Space
-      currentChar != '\u{00A0}'  && // No Break Space
-      currentChar != '\u{FEFF}'  && // ZERO WIDTH NO-BREAK SPACE
+      currentChar != '\u{0009}' && // Tab
+      currentChar != '\u{000B}' && // LINE TABULATION
+      currentChar != '\u{000C}' && // FORM FEED (FF)
+      currentChar != '\u{0020}' && // Space
+      currentChar != '\u{00A0}' && // No Break Space
+      currentChar != '\u{FEFF}' && // ZERO WIDTH NO-BREAK SPACE
       // Line Terminators
       currentChar != '\n' && // LF
       currentChar != '\r' // CR
     ) break
   }
-  if (end) slice(0, i+1, str)
-  else slice(i, charsLength, str)
+  if (end) slice(0, i + 1, str) else slice(i, charsLength, str)
 }
 /**
  * Trims the beginning of a string—removing any leading whitespace characters.