@grain/stdlib 0.6.6 → 0.7.1

package/string.gr

@@ -24,7 +24,38 @@ use DataStructures.{
   allocateString,
   allocateBytes,
 }
+from "runtime/utf8" include Utf8
+use Utf8.{
+  isLeadingByte,
+  utf8ByteCount,
+  usvEncodeLength,
+  getCodePoint,
+  writeUtf8CodePoint,
+}
+from "runtime/unsafe/offsets" include Offsets
+use Offsets.{
+  _STR_LEN_OFFSET,
+  _STR_DATA_OFFSET,
+  _ARRAY_LEN_OFFSET,
+  _ARRAY_DATA_OFFSET,
+  _ARRAY_ITEM_SIZE,
+  _BYTES_LEN_OFFSET,
+  _BYTES_DATA_OFFSET,
+}
+from "runtime/unsafe/tags" include Tags
 
+// Helpers
+@unsafe
+let convSimpleNumber = (x: Number, err: String) => {
+  use WasmI32.{ (&), (!=) }
+  let rawX = WasmI32.fromGrain(x)
+  if ((rawX & Tags._GRAIN_NUMBER_TAG_MASK) != Tags._GRAIN_NUMBER_TAG_TYPE) {
+    throw InvalidArgument(err)
+  }
+  untagSimpleNumber(x)
+}
+@unsafe
+let rawByteLength = (ptr: WasmI32) => WasmI32.load(ptr, _STR_LEN_OFFSET)
 /**
  * Byte encodings
  */
@@ -63,20 +94,18 @@ provide let concat = (++)
  */
 @unsafe
 provide let length = (string: String) => {
-  use WasmI32.{ (+), (&), (!=) }
-  let stringPtr = WasmI32.fromGrain(string)
-  let size = WasmI32.load(stringPtr, 4n)
+  use WasmI32.{ (+), (&), (!=), ltU as (<) }
+  let mut stringPtr = WasmI32.fromGrain(string)
+  let size = rawByteLength(stringPtr)
 
   let mut len = 0n
-  let mut ptr = stringPtr + 8n
-  let end = ptr + size
+  stringPtr += _STR_DATA_OFFSET
+  let end = stringPtr + size
 
-  while (WasmI32.ltU(ptr, end)) {
-    let byte = WasmI32.load8U(ptr, 0n)
-    if ((byte & 0xC0n) != 0x80n) {
-      len += 1n
-    }
-    ptr += 1n
+  while (stringPtr < end) {
+    let byte = WasmI32.load8U(stringPtr, 0n)
+    if (isLeadingByte(byte)) len += 1n
+    stringPtr += 1n
   }
 
   ignore(string)
@@ -97,7 +126,7 @@ provide let length = (string: String) => {
 @unsafe
 provide let byteLength = (string: String) => {
   let stringPtr = WasmI32.fromGrain(string)
-  let result = Conv.wasmI32ToNumber(WasmI32.load(stringPtr, 4n))
+  let result = Conv.wasmI32ToNumber(rawByteLength(stringPtr))
   ignore(string)
   result
 }
@@ -114,7 +143,7 @@ provide let byteLength = (string: String) => {
 provide let isEmpty = (string: String) => {
   use WasmI32.{ (==) }
   let strPtr = WasmI32.fromGrain(string)
-  let result = WasmI32.load(strPtr, 4n) == 0n
+  let result = rawByteLength(strPtr) == 0n
   ignore(string)
   result
 }
@@ -132,36 +161,26 @@ provide let isEmpty = (string: String) => {
  */
 @unsafe
 provide let indexOf = (search: String, string: String) => {
+  use WasmI32.{ (+), (-), ltU as (<), gtU as (>), (==) }
   let searchPtr = WasmI32.fromGrain(search)
   let stringPtr = WasmI32.fromGrain(string)
 
-  let size = WasmI32.load(stringPtr, 4n)
-  let psize = WasmI32.load(searchPtr, 4n)
-  use WasmI32.{ (+), (-), (&), ltU as (<), gtU as (>), (==) }
+  let size = rawByteLength(stringPtr)
+  let psize = rawByteLength(searchPtr)
 
   if (psize > size) {
     return None
   }
-  let mut idx = 0n
-  let mut ptr = stringPtr + 8n
-  let pptr = searchPtr + 8n
+  let mut ptr = stringPtr + _STR_DATA_OFFSET
+  let pptr = searchPtr + _STR_DATA_OFFSET
   let end = ptr + size - psize + 1n
 
-  while (ptr < end) {
+  for (let mut i = 0n; ptr < end; i += 1n) {
     if (Memory.compare(ptr, pptr, psize) == 0n) {
-      return Some(tagSimpleNumber(idx))
+      return Some(tagSimpleNumber(i))
     }
-    idx += 1n
     let byte = WasmI32.load8U(ptr, 0n)
-    if ((byte & 0x80n) == 0x00n) {
-      ptr += 1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      ptr += 4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      ptr += 3n
-    } else {
-      ptr += 2n
-    }
+    ptr += utf8ByteCount(byte)
   }
 
   ignore(search)
@@ -186,28 +205,26 @@ provide let lastIndexOf = (search: String, string: String) => {
   // The last possible index in the string given the length of the search
   let lastIndex = length(string) - length(search)
 
-  use WasmI32.{ (+), (-), (&), gtU as (>), geU as (>=), (==), (!=) }
+  use WasmI32.{ (+), (-), gtU as (>), geU as (>=), (==), (!=) }
 
   let searchPtr = WasmI32.fromGrain(search)
   let stringPtr = WasmI32.fromGrain(string)
-  let searchSize = WasmI32.load(searchPtr, 4n)
-  let stringSize = WasmI32.load(stringPtr, 4n)
+  let searchSize = rawByteLength(searchPtr)
+  let stringSize = rawByteLength(stringPtr)
   if (searchSize > stringSize) {
     return None
   }
   let mut stringIndex = untagSimpleNumber(lastIndex)
-  let searchPtr = searchPtr + 8n
-  let stringStartPtr = stringPtr + 8n
+  let searchPtr = searchPtr + _STR_DATA_OFFSET
+  let stringStartPtr = stringPtr + _STR_DATA_OFFSET
   for (
     let mut stringPtr = stringStartPtr + stringSize - searchSize;
     stringPtr >= stringStartPtr;
     stringPtr -= 1n
   ) {
     let byte = WasmI32.load8U(stringPtr, 0n)
-    if ((byte & 0xC0n) == 0x80n) {
-      // We're not at the start of a codepoint, so move on
-      continue
-    }
+    // We're not at the start of a codepoint, so move on
+    if (!isLeadingByte(byte)) continue
     if (Memory.compare(stringPtr, searchPtr, searchSize) == 0n) {
       return Some(tagSimpleNumber(stringIndex))
     }
@@ -220,68 +237,17 @@ provide let lastIndexOf = (search: String, string: String) => {
   return None
 }
 
-@unsafe
-let getCodePoint = (ptr: WasmI32) => {
-  // Algorithm from https://encoding.spec.whatwg.org/#utf-8-decoder
-  use WasmI32.{ (+), (&), (|), (<<), leU as (<=), geU as (>=), (==) }
-
-  let mut codePoint = 0n
-  let mut bytesSeen = 0n
-  let mut bytesNeeded = 0n
-  let mut lowerBoundary = 0x80n
-  let mut upperBoundary = 0xBFn
-
-  let mut offset = 0n
-
-  while (true) {
-    let byte = WasmI32.load8U(ptr + offset, 0n)
-    offset += 1n
-    if (bytesNeeded == 0n) {
-      if (byte >= 0x00n && byte <= 0x7Fn) {
-        return byte
-      } 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) {
-      return codePoint
-    }
-  }
-  return 0n
-}
-
 @unsafe
 let charAtHelp = (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
-  use WasmI32.{ (+), (&), (>>>), ltU as (<), (==) }
-  let size = WasmI32.fromGrain(byteLength(string)) >>> 1n
-  let position = WasmI32.fromGrain(position) >>> 1n
-  let stringPre = WasmI32.fromGrain(string)
-  let mut ptr = stringPre + 8n
+  use WasmI32.{ (+), ltU as (<), (==) }
+  let stringPtr = WasmI32.fromGrain(string)
+  let size = rawByteLength(stringPtr)
+  let position = untagSimpleNumber(position)
+  let mut ptr = stringPtr + _STR_DATA_OFFSET
   let end = ptr + size
   let mut counter = 0n
   while (ptr < end) {
@@ -289,17 +255,8 @@ let charAtHelp = (position, string: String) => {
       return getCodePoint(ptr)
     }
     let byte = WasmI32.load8U(ptr, 0n)
-    let n = if ((byte & 0x80n) == 0x00n) {
-      1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      3n
-    } else {
-      2n
-    }
+    ptr += utf8ByteCount(byte)
     counter += 1n
-    ptr += n
   }
 
   ignore(string)
@@ -347,14 +304,13 @@ provide let charAt = (position, string: String) => {
 
 @unsafe
 let explodeHelp = (s: String, chars) => {
-  use WasmI32.{ (+), (&), (>>>), ltU as (<), (==) }
-
-  let size = WasmI32.fromGrain(byteLength(s)) >>> 1n
-  let len = WasmI32.fromGrain(length(s)) >>> 1n
+  use WasmI32.{ (+), ltU as (<), (==) }
 
   let sPtr = WasmI32.fromGrain(s)
+  let size = rawByteLength(sPtr)
+  let len = untagSimpleNumber(length(s))
 
-  let mut ptr = sPtr + 8n
+  let mut ptr = sPtr + _STR_DATA_OFFSET
   let end = ptr + size
 
   let arr = allocateArray(len)
@@ -362,26 +318,18 @@ let explodeHelp = (s: String, chars) => {
 
   while (ptr < end) {
     let byte = WasmI32.load8U(ptr, 0n)
-    let n = if ((byte & 0x80n) == 0x00n) {
-      1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      3n
-    } else {
-      2n
-    }
+    let n = utf8ByteCount(byte)
 
     let c = if (chars) {
       WasmI32.fromGrain(tagChar(getCodePoint(ptr)))
     } else {
       let sPtr = allocateString(n)
-      Memory.copy(sPtr + 8n, ptr, n)
+      Memory.copy(sPtr + _STR_DATA_OFFSET, ptr, n)
       sPtr
     }
 
-    WasmI32.store(arr + arrIdx, c, 8n)
-    arrIdx += 4n
+    WasmI32.store(arr + arrIdx, c, _ARRAY_DATA_OFFSET)
+    arrIdx += _ARRAY_ITEM_SIZE
     ptr += n
   }
 
@@ -432,58 +380,21 @@ provide let implode = (arr: Array<Char>) => {
     leU as (<=),
   }
 
-  let arrLength = WasmI32.load(WasmI32.fromGrain(arr), 4n)
+  let arrLength = WasmI32.load(WasmI32.fromGrain(arr), _ARRAY_LEN_OFFSET)
 
   let mut stringByteLength = 0n
 
   for (let mut i = 0n; i < arrLength; i += 1n) {
     let usv = untagChar(arr[tagSimpleNumber(i)])
-
-    let n = if (usv <= 0x7Fn) {
-      1n
-    } else if (usv <= 0x07FFn) {
-      2n
-    } else if (usv <= 0xFFFFn) {
-      3n
-    } else {
-      4n
-    }
-
-    stringByteLength += n
+    stringByteLength += usvEncodeLength(usv)
   }
 
   let str = allocateString(stringByteLength)
-  let mut offset = 8n
+  let mut offset = _STR_DATA_OFFSET
 
   for (let mut i = 0n; i < arrLength; i += 1n) {
     let usv = untagChar(arr[tagSimpleNumber(i)])
-
-    if (usv < 0x7Fn) {
-      WasmI32.store8(str + offset, usv, 0n)
-      offset += 1n
-    } else {
-      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
-      }
-    }
+    offset += writeUtf8CodePoint(str + offset, usv)
   }
 
   WasmI32.toGrain(str): String
@@ -529,21 +440,21 @@ provide let reverse = string => {
  */
 @unsafe
 provide let split = (separator: String, string: String) => {
-  use WasmI32.{ (+), (-), (&), (<<), (>>), ltU as (<), gtU as (>), (==) }
+  use WasmI32.{ (+), (-), (&), (<<), ltU as (<), gtU as (>), (==) }
 
-  let size = WasmI32.fromGrain(byteLength(string)) >> 1n
-  let psize = WasmI32.fromGrain(byteLength(separator)) >> 1n
+  let stringPtr = WasmI32.fromGrain(string)
+  let separatorPtr = WasmI32.fromGrain(separator)
+  let size = rawByteLength(stringPtr)
+  let psize = rawByteLength(separatorPtr)
 
   if (psize == 0n) {
     WasmI32.toGrain(explodeHelp(string, false)): Array<String>
   } else if (psize > size) {
     [> string]
   } else {
-    let stringPtr = WasmI32.fromGrain(string)
-    let separatorPtr = WasmI32.fromGrain(separator)
-
-    let mut ptr = stringPtr + 8n
-    let mut pptr = separatorPtr + 8n
+    let stringPtr = stringPtr + _STR_DATA_OFFSET
+    let mut ptr = stringPtr
+    let mut pptr = separatorPtr + _STR_DATA_OFFSET
     let end = ptr + size - psize + 1n
 
     let mut numStrings = 1n
@@ -553,18 +464,10 @@ provide let split = (separator: String, string: String) => {
         numStrings += 1n
       }
       let byte = WasmI32.load8U(ptr, 0n)
-      if ((byte & 0x80n) == 0x00n) {
-        ptr += 1n
-      } else if ((byte & 0xF0n) == 0xF0n) {
-        ptr += 4n
-      } else if ((byte & 0xE0n) == 0xE0n) {
-        ptr += 3n
-      } else {
-        ptr += 2n
-      }
+      ptr += utf8ByteCount(byte)
     }
 
-    ptr = stringPtr + 8n
+    ptr = stringPtr
     let mut last = ptr
     let arr = allocateArray(numStrings)
     let mut arrIdx = 0n
@@ -573,30 +476,22 @@ provide let split = (separator: String, string: String) => {
       if (Memory.compare(ptr, pptr, psize) == 0n) {
         let strSize = ptr - last
         let str = allocateString(strSize)
-        Memory.copy(str + 8n, last, strSize)
-        WasmI32.store(arr + arrIdx, str, 8n)
-        arrIdx += 4n
+        Memory.copy(str + _STR_DATA_OFFSET, last, strSize)
+        WasmI32.store(arr + _ARRAY_DATA_OFFSET, str, arrIdx)
+        arrIdx += _ARRAY_ITEM_SIZE
         ptr += psize
         last = ptr
         continue
       }
       let byte = WasmI32.load8U(ptr, 0n)
-      if ((byte & 0x80n) == 0x00n) {
-        ptr += 1n
-      } else if ((byte & 0xF0n) == 0xF0n) {
-        ptr += 4n
-      } else if ((byte & 0xE0n) == 0xE0n) {
-        ptr += 3n
-      } else {
-        ptr += 2n
-      }
+      ptr += utf8ByteCount(byte)
     }
 
     // Grab last string
-    let strSize = stringPtr + 8n + size - last
+    let strSize = stringPtr + size - last
     let lastStr = allocateString(strSize)
-    Memory.copy(lastStr + 8n, last, strSize)
-    WasmI32.store(arr + arrIdx, lastStr, 8n)
+    Memory.copy(lastStr + _STR_DATA_OFFSET, last, strSize)
+    WasmI32.store(arr + arrIdx, lastStr, _ARRAY_DATA_OFFSET)
 
     ignore(separator)
     ignore(string)
@@ -627,24 +522,14 @@ provide let split = (separator: String, string: String) => {
  */
 @unsafe
 provide let slice = (start: Number, end=length(string), string: String) => {
-  use WasmI32.{ (+), (-), (&), (<<), (>>), (<), (>), (==), (!=) }
-
-  let len = WasmI32.fromGrain(length(string)) >> 1n
-  let size = WasmI32.fromGrain(byteLength(string)) >> 1n
+  use WasmI32.{ (+), (-), (<), (>), (==) }
 
   let stringPtr = WasmI32.fromGrain(string)
+  let len = untagSimpleNumber(length(string))
+  let size = rawByteLength(stringPtr)
 
-  let mut start = WasmI32.fromGrain(start)
-  if ((start & 1n) != 1n) {
-    throw InvalidArgument("Invalid start index")
-  }
-  start = start >> 1n
-
-  let mut to = WasmI32.fromGrain(end)
-  if ((to & 1n) != 1n) {
-    throw InvalidArgument("Invalid end index")
-  }
-  to = to >> 1n
+  let mut start = convSimpleNumber(start, "Invalid start index")
+  let mut to = convSimpleNumber(end, "Invalid end index")
 
   if (start < 0n) {
     start += len
@@ -661,7 +546,7 @@ provide let slice = (start: Number, end=length(string), string: String) => {
     throw InvalidArgument("Start index exceeds end index")
   }
 
-  let mut ptr = stringPtr + 8n
+  let mut ptr = stringPtr + _STR_DATA_OFFSET
   let mut begin = ptr
   let mut end = ptr
   let stop = ptr + size
@@ -669,7 +554,7 @@ provide let slice = (start: Number, end=length(string), string: String) => {
   let mut idx = 0n
   while (ptr < stop) {
     let byte = WasmI32.load8U(ptr, 0n)
-    if ((byte & 0xC0n) != 0x80n) {
+    if (isLeadingByte(byte)) {
       if (idx == start) {
         begin = ptr
       }
@@ -682,7 +567,7 @@ provide let slice = (start: Number, end=length(string), string: String) => {
     ptr += 1n
   }
   if (to == len) {
-    end = stringPtr + 8n + size
+    end = stringPtr + _STR_DATA_OFFSET + size
   }
   if (start == to) {
     begin = end
@@ -691,7 +576,7 @@ provide let slice = (start: Number, end=length(string), string: String) => {
   let newSize = end - begin
   let newString = allocateString(newSize)
 
-  Memory.copy(newString + 8n, begin, newSize)
+  Memory.copy(newString + _STR_DATA_OFFSET, begin, newSize)
 
   ignore(string)
 
@@ -715,27 +600,18 @@ provide let contains = (search: String, string: String) => {
   // searching phase in O(nm) time complexity
   // slightly (by coefficient) sub-linear in the average case
   // http://igm.univ-mlv.fr/~lecroq/string/node13.html#SECTION00130
-  use WasmI32.{
-    (+),
-    (-),
-    (>>),
-    ltU as (<),
-    gtU as (>),
-    leU as (<=),
-    (==),
-    (!=),
-  }
+  use WasmI32.{ (+), (-), ltU as (<), gtU as (>), leU as (<=), (==), (!=) }
   let pOrig = search
   let sOrig = string
 
-  let n = WasmI32.fromGrain(byteLength(string)) >> 1n
-  let m = WasmI32.fromGrain(byteLength(search)) >> 1n
-
   let mut stringPtr = WasmI32.fromGrain(string)
   let mut searchPtr = WasmI32.fromGrain(search)
 
-  stringPtr += 8n
-  searchPtr += 8n
+  let n = rawByteLength(stringPtr)
+  let m = rawByteLength(searchPtr)
+
+  stringPtr += _STR_DATA_OFFSET
+  searchPtr += _STR_DATA_OFFSET
 
   let mut j = 0n
   and k = 0n
@@ -779,8 +655,8 @@ provide let contains = (search: String, string: String) => {
       j += k
     } else {
       if (
-        Memory.compare(searchPtr + 2n, stringPtr + j + 2n, m - 2n) == 0n &&
-        WasmI32.load8U(searchPtr, 0n) == WasmI32.load8U(stringPtr + j, 0n)
+        Memory.compare(searchPtr + 2n, stringPtr + j + 2n, m - 2n) == 0n
+        && WasmI32.load8U(searchPtr, 0n) == WasmI32.load8U(stringPtr + j, 0n)
       ) {
         return true
       }
@@ -814,11 +690,11 @@ provide let startsWith = (search: String, string: String) => {
   let mut searchPtr = WasmI32.fromGrain(search)
   let mut stringPtr = WasmI32.fromGrain(string)
 
-  let n = WasmI32.load(stringPtr, 4n)
-  let m = WasmI32.load(searchPtr, 4n)
+  let n = rawByteLength(stringPtr)
+  let m = rawByteLength(searchPtr)
 
-  stringPtr += 8n
-  searchPtr += 8n
+  stringPtr += _STR_DATA_OFFSET
+  searchPtr += _STR_DATA_OFFSET
 
   // Bail if pattern length is longer than input length
   let result = if (m > n) {
@@ -853,11 +729,11 @@ provide let endsWith = (search: String, string: String) => {
   let mut searchPtr = WasmI32.fromGrain(search)
   let mut stringPtr = WasmI32.fromGrain(string)
 
-  let n = WasmI32.load(stringPtr, 4n)
-  let m = WasmI32.load(searchPtr, 4n)
+  let n = rawByteLength(stringPtr)
+  let m = rawByteLength(searchPtr)
 
-  stringPtr += 8n
-  searchPtr += 8n
+  stringPtr += _STR_DATA_OFFSET
+  searchPtr += _STR_DATA_OFFSET
 
   // Bail if pattern length is longer than input length
   let result = if (m > n) {
@@ -896,16 +772,16 @@ provide let replaceFirst = (
   let mut stringPtr = WasmI32.fromGrain(string)
   let mut replacementPtr = WasmI32.fromGrain(replacement)
 
-  let patternLen = WasmI32.load(patternPtr, 4n)
-  let stringLen = WasmI32.load(stringPtr, 4n)
-  let replacementLen = WasmI32.load(replacementPtr, 4n)
+  let patternLen = rawByteLength(patternPtr)
+  let stringLen = rawByteLength(stringPtr)
+  let replacementLen = rawByteLength(replacementPtr)
   // Bail if search str is longer than the string
   if (stringLen < patternLen) {
     return string
   }
-  patternPtr += 8n
-  stringPtr += 8n
-  replacementPtr += 8n
+  patternPtr += _STR_DATA_OFFSET
+  stringPtr += _STR_DATA_OFFSET
+  replacementPtr += _STR_DATA_OFFSET
 
   // Search for an instance of the string
   let mut foundIndex = -1n
@@ -916,7 +792,7 @@ provide let replaceFirst = (
     if (Memory.compare(i, patternPtr, patternLen) == 0n) {
       // Create the new string
       let str = allocateString(stringLen - patternLen + replacementLen)
-      let strPtr = str + 8n
+      let strPtr = str + _STR_DATA_OFFSET
       Memory.copy(strPtr, stringPtr, foundIndex)
       Memory.copy(strPtr + foundIndex, replacementPtr, replacementLen)
       Memory.copy(
@@ -960,17 +836,17 @@ provide let replaceLast = (
   let mut stringPtr = WasmI32.fromGrain(string)
   let mut replacementPtr = WasmI32.fromGrain(replacement)
 
-  let patternLen = WasmI32.load(patternPtr, 4n)
-  let stringLen = WasmI32.load(stringPtr, 4n)
-  let replacementLen = WasmI32.load(replacementPtr, 4n)
+  let patternLen = rawByteLength(patternPtr)
+  let stringLen = rawByteLength(stringPtr)
+  let replacementLen = rawByteLength(replacementPtr)
 
   // Bail if search str is longer than the string
   if (stringLen < patternLen) {
     return string
   }
-  patternPtr += 8n
-  stringPtr += 8n
-  replacementPtr += 8n
+  patternPtr += _STR_DATA_OFFSET
+  stringPtr += _STR_DATA_OFFSET
+  replacementPtr += _STR_DATA_OFFSET
 
   let mut found = false
   // Search for an instance of the string
@@ -982,7 +858,7 @@ provide let replaceLast = (
     if (Memory.compare(i, patternPtr, patternLen) == 0n) {
       // Create the new string
       let str = allocateString(stringLen - patternLen + replacementLen)
-      let strPtr = str + 8n
+      let strPtr = str + _STR_DATA_OFFSET
       Memory.copy(strPtr, stringPtr, foundIndex)
       Memory.copy(strPtr + foundIndex, replacementPtr, replacementLen)
       Memory.copy(
@@ -1020,23 +896,23 @@ provide let replaceAll = (
   replacement: String,
   string: String,
 ) => {
-  use WasmI32.{ (+), (-), (*), (>>), gtU as (>), ltU as (<), (==) }
+  use WasmI32.{ (+), (-), (*), gtU as (>), ltU as (<), (==) }
 
   let mut patternPtr = WasmI32.fromGrain(searchPattern)
   let mut stringPtr = WasmI32.fromGrain(string)
   let mut replacementPtr = WasmI32.fromGrain(replacement)
 
-  let patternLen = WasmI32.load(patternPtr, 4n)
-  let stringLen = WasmI32.load(stringPtr, 4n)
-  let replacementLen = WasmI32.load(replacementPtr, 4n)
+  let patternLen = rawByteLength(patternPtr)
+  let stringLen = rawByteLength(stringPtr)
+  let replacementLen = rawByteLength(replacementPtr)
 
   // Bail if search str is longer than the string
   let result = if (stringLen < patternLen) {
     string
   } else {
-    patternPtr += 8n
-    stringPtr += 8n
-    replacementPtr += 8n
+    patternPtr += _STR_DATA_OFFSET
+    stringPtr += _STR_DATA_OFFSET
+    replacementPtr += _STR_DATA_OFFSET
 
     let mut found = false
     // Search for an instance of the string
@@ -1060,7 +936,7 @@ provide let replaceAll = (
       let str = allocateString(
         stringLen - (patternLen - replacementLen) * foundCount
       )
-      let mut strPtr = str + 8n
+      let mut strPtr = str + _STR_DATA_OFFSET
       let mut lastIndex = 0n
       while (true) {
         match (foundIndexes) {
@@ -1102,44 +978,30 @@ let _OFFSET_NAME = "offset"
 
 @unsafe
 let grainToWasmNumber = (num, name) => {
-  use WasmI32.{ (&), (>>), (<) }
-  let num = WasmI32.fromGrain(num)
-  if (WasmI32.eqz(num & 1n)) {
-    let str = " argument must be an integer"
-    throw Exception.InvalidArgument(name ++ str)
+  use WasmI32.{ (<) }
+  let _num = convSimpleNumber(num, name ++ " argument must be an integer")
+  if (_num < 0n) {
+    throw InvalidArgument(name ++ " argument must be non-negative")
   }
-  let num = num >> 1n
-  if (num < 0n) {
-    let str = " argument must be non-negative"
-    throw Exception.InvalidArgument(name ++ str)
-  }
-  num
+  ignore(num)
+  _num
 }
 
 @unsafe
 let utf16Length = (s: String) => {
-  use WasmI32.{ (+), (&), (>>>), (<<), ltU as (<), (==) }
-
-  let size = WasmI32.fromGrain(byteLength(s)) >>> 1n
-  let len = WasmI32.fromGrain(length(s)) >>> 1n
+  use WasmI32.{ (+), (<<), ltU as (<), (==) }
 
   let sPtr = WasmI32.fromGrain(s)
+  let size = rawByteLength(sPtr)
+  let len = untagSimpleNumber(length(s))
 
-  let mut ptr = sPtr + 8n
+  let mut ptr = sPtr + _STR_DATA_OFFSET
   let end = ptr + size
   let mut size = 0n // <- number of UTF-16 code words
 
   while (ptr < end) {
     let byte = WasmI32.load8U(ptr, 0n)
-    let n = if ((byte & 0x80n) == 0x00n) {
-      1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      3n
-    } else {
-      2n
-    }
+    let n = utf8ByteCount(byte)
     if (n == 4n) {
       size += 2n
     } else {
@@ -1164,11 +1026,6 @@ let encodedLength = (s: String, encoding) => {
   }
 }
 
-@unsafe
-let mut _BYTES_SIZE_OFFSET = 4n
-@unsafe
-let mut _BYTES_OFFSET = 8n
-
 @unsafe
 let encodeAtHelp = (
   string: String,
@@ -1178,18 +1035,17 @@ let encodeAtHelp = (
   destPos: Number,
 ) => {
   use WasmI32.{ (+), (-), (&), (>>>), ltU as (<), (>), leU as (<=), (==) }
-  let byteSize = WasmI32.fromGrain(byteLength(string)) >>> 1n
-  let len = WasmI32.fromGrain(length(string)) >>> 1n
-
   let stringPtr = WasmI32.fromGrain(string)
+  let byteSize = rawByteLength(stringPtr)
+  let len = untagSimpleNumber(length(string))
 
-  let mut ptr = stringPtr + 8n
+  let mut ptr = stringPtr + _STR_DATA_OFFSET
   let end = ptr + byteSize
 
   let bytes = WasmI32.fromGrain(dest)
   let mut bytesIdx = grainToWasmNumber(destPos, _OFFSET_NAME)
 
-  let destSize = WasmI32.load(bytes, _BYTES_SIZE_OFFSET)
+  let destSize = WasmI32.load(bytes, _BYTES_LEN_OFFSET)
 
   if (includeBom) {
     match (encoding) {
@@ -1197,45 +1053,45 @@ let encodeAtHelp = (
         if (bytesIdx + 3n > destSize) {
           throw IndexOutOfBounds
         }
-        WasmI32.store8(bytes + bytesIdx, 0xEFn, _BYTES_OFFSET)
-        WasmI32.store8(bytes + bytesIdx + 1n, 0xBBn, _BYTES_OFFSET)
-        WasmI32.store8(bytes + bytesIdx + 2n, 0xBFn, _BYTES_OFFSET)
+        WasmI32.store8(bytes + bytesIdx, 0xEFn, _BYTES_DATA_OFFSET)
+        WasmI32.store8(bytes + bytesIdx + 1n, 0xBBn, _BYTES_DATA_OFFSET)
+        WasmI32.store8(bytes + bytesIdx + 2n, 0xBFn, _BYTES_DATA_OFFSET)
         bytesIdx += 3n
       },
       UTF16_BE => {
         if (bytesIdx + 2n > destSize) {
           throw IndexOutOfBounds
         }
-        WasmI32.store8(bytes + bytesIdx, 0xFEn, _BYTES_OFFSET)
-        WasmI32.store8(bytes + bytesIdx + 1n, 0xFFn, _BYTES_OFFSET)
+        WasmI32.store8(bytes + bytesIdx, 0xFEn, _BYTES_DATA_OFFSET)
+        WasmI32.store8(bytes + bytesIdx + 1n, 0xFFn, _BYTES_DATA_OFFSET)
         bytesIdx += 2n
       },
       UTF16_LE => {
         if (bytesIdx + 2n > destSize) {
           throw IndexOutOfBounds
         }
-        WasmI32.store8(bytes + bytesIdx, 0xFFn, _BYTES_OFFSET)
-        WasmI32.store8(bytes + bytesIdx + 1n, 0xFEn, _BYTES_OFFSET)
+        WasmI32.store8(bytes + bytesIdx, 0xFFn, _BYTES_DATA_OFFSET)
+        WasmI32.store8(bytes + bytesIdx + 1n, 0xFEn, _BYTES_DATA_OFFSET)
         bytesIdx += 2n
       },
       UTF32_BE => {
         if (bytesIdx + 4n > destSize) {
           throw IndexOutOfBounds
         }
-        WasmI32.store8(bytes + bytesIdx, 0n, _BYTES_OFFSET)
-        WasmI32.store8(bytes + bytesIdx + 1n, 0n, _BYTES_OFFSET)
-        WasmI32.store8(bytes + bytesIdx + 2n, 0xFEn, _BYTES_OFFSET)
-        WasmI32.store8(bytes + bytesIdx + 3n, 0xFFn, _BYTES_OFFSET)
+        WasmI32.store8(bytes + bytesIdx, 0n, _BYTES_DATA_OFFSET)
+        WasmI32.store8(bytes + bytesIdx + 1n, 0n, _BYTES_DATA_OFFSET)
+        WasmI32.store8(bytes + bytesIdx + 2n, 0xFEn, _BYTES_DATA_OFFSET)
+        WasmI32.store8(bytes + bytesIdx + 3n, 0xFFn, _BYTES_DATA_OFFSET)
         bytesIdx += 4n
       },
       UTF32_LE => {
         if (bytesIdx + 4n > destSize) {
           throw IndexOutOfBounds
         }
-        WasmI32.store8(bytes + bytesIdx, 0xFFn, _BYTES_OFFSET)
-        WasmI32.store8(bytes + bytesIdx + 1n, 0xFEn, _BYTES_OFFSET)
-        WasmI32.store8(bytes + bytesIdx + 2n, 0n, _BYTES_OFFSET)
-        WasmI32.store8(bytes + bytesIdx + 3n, 0n, _BYTES_OFFSET)
+        WasmI32.store8(bytes + bytesIdx, 0xFFn, _BYTES_DATA_OFFSET)
+        WasmI32.store8(bytes + bytesIdx + 1n, 0xFEn, _BYTES_DATA_OFFSET)
+        WasmI32.store8(bytes + bytesIdx + 2n, 0n, _BYTES_DATA_OFFSET)
+        WasmI32.store8(bytes + bytesIdx + 3n, 0n, _BYTES_DATA_OFFSET)
         bytesIdx += 4n
       },
     }
@@ -1249,21 +1105,13 @@ let encodeAtHelp = (
       if (bytesIdx + byteSize > destSize) {
         throw IndexOutOfBounds
       }
-      Memory.copy(bytes + bytesIdx + _BYTES_OFFSET, ptr, byteSize)
+      Memory.copy(bytes + bytesIdx + _BYTES_DATA_OFFSET, ptr, byteSize)
     },
     _ => {
       while (ptr < end) {
         let byte = WasmI32.load8U(ptr, 0n)
         // number of bytes spanning this UTF-8-encoded scalar value
-        let n = if ((byte & 0x80n) == 0x00n) {
-          1n
-        } else if ((byte & 0xF0n) == 0xF0n) {
-          4n
-        } else if ((byte & 0xE0n) == 0xE0n) {
-          3n
-        } else {
-          2n
-        }
+        let n = utf8ByteCount(byte)
         match (encoding) {
           UTF8 => {
             // With the optimization above for bulk memory copy, this match
@@ -1271,7 +1119,7 @@ let encodeAtHelp = (
             if (bytesIdx + n > destSize) {
               throw IndexOutOfBounds
             }
-            Memory.copy(bytes + bytesIdx + _BYTES_OFFSET, ptr, n)
+            Memory.copy(bytes + bytesIdx + _BYTES_DATA_OFFSET, ptr, n)
             bytesIdx += n
           },
           UTF16_BE => {
@@ -1284,12 +1132,12 @@ let encodeAtHelp = (
               WasmI32.store8(
                 bytes + bytesIdx,
                 (codePoint & 0xff00n) >>> 8n,
-                _BYTES_OFFSET
+                _BYTES_DATA_OFFSET
               )
               WasmI32.store8(
                 bytes + bytesIdx + 1n,
                 codePoint & 0xffn,
-                _BYTES_OFFSET
+                _BYTES_DATA_OFFSET
               )
               bytesIdx += 2n
             } else {
@@ -1303,15 +1151,23 @@ let encodeAtHelp = (
               WasmI32.store8(
                 bytes + bytesIdx,
                 (w1 & 0xff00n) >>> 8n,
-                _BYTES_OFFSET
+                _BYTES_DATA_OFFSET
+              )
+              WasmI32.store8(
+                bytes + bytesIdx + 1n,
+                w1 & 0xffn,
+                _BYTES_DATA_OFFSET
               )
-              WasmI32.store8(bytes + bytesIdx + 1n, w1 & 0xffn, _BYTES_OFFSET)
               WasmI32.store8(
                 bytes + bytesIdx + 2n,
                 (w2 & 0xff00n) >>> 8n,
-                _BYTES_OFFSET
+                _BYTES_DATA_OFFSET
+              )
+              WasmI32.store8(
+                bytes + bytesIdx + 3n,
+                w2 & 0xffn,
+                _BYTES_DATA_OFFSET
               )
-              WasmI32.store8(bytes + bytesIdx + 3n, w2 & 0xffn, _BYTES_OFFSET)
               bytesIdx += 4n
             }
           },
@@ -1322,11 +1178,15 @@ let encodeAtHelp = (
                 throw IndexOutOfBounds
               }
               // <lo><hi>
-              WasmI32.store8(bytes + bytesIdx, codePoint & 0xffn, _BYTES_OFFSET)
+              WasmI32.store8(
+                bytes + bytesIdx,
+                codePoint & 0xffn,
+                _BYTES_DATA_OFFSET
+              )
               WasmI32.store8(
                 bytes + bytesIdx + 1n,
                 (codePoint & 0xff00n) >>> 8n,
-                _BYTES_OFFSET
+                _BYTES_DATA_OFFSET
               )
               bytesIdx += 2n
             } else {
@@ -1337,17 +1197,21 @@ let encodeAtHelp = (
               let uPrime = codePoint - 0x10000n
               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, w1 & 0xffn, _BYTES_DATA_OFFSET)
               WasmI32.store8(
                 bytes + bytesIdx + 1n,
                 (w1 & 0xff00n) >>> 8n,
-                _BYTES_OFFSET
+                _BYTES_DATA_OFFSET
+              )
+              WasmI32.store8(
+                bytes + bytesIdx + 2n,
+                w2 & 0xffn,
+                _BYTES_DATA_OFFSET
               )
-              WasmI32.store8(bytes + bytesIdx + 2n, w2 & 0xffn, _BYTES_OFFSET)
               WasmI32.store8(
                 bytes + bytesIdx + 3n,
                 (w2 & 0xff00n) >>> 8n,
-                _BYTES_OFFSET
+                _BYTES_DATA_OFFSET
               )
               bytesIdx += 4n
             }
@@ -1360,22 +1224,22 @@ let encodeAtHelp = (
             WasmI32.store8(
               bytes + bytesIdx,
               (codePoint & 0xff000000n) >>> 24n,
-              _BYTES_OFFSET
+              _BYTES_DATA_OFFSET
             )
             WasmI32.store8(
               bytes + bytesIdx + 1n,
               (codePoint & 0xff0000n) >>> 16n,
-              _BYTES_OFFSET
+              _BYTES_DATA_OFFSET
             )
             WasmI32.store8(
               bytes + bytesIdx + 2n,
               (codePoint & 0xff00n) >>> 8n,
-              _BYTES_OFFSET
+              _BYTES_DATA_OFFSET
             )
             WasmI32.store8(
               bytes + bytesIdx + 3n,
               codePoint & 0xffn,
-              _BYTES_OFFSET
+              _BYTES_DATA_OFFSET
             )
             bytesIdx += 4n
           },
@@ -1384,21 +1248,25 @@ let encodeAtHelp = (
               throw IndexOutOfBounds
             }
             let codePoint = getCodePoint(ptr)
-            WasmI32.store8(bytes + bytesIdx, codePoint & 0xffn, _BYTES_OFFSET)
+            WasmI32.store8(
+              bytes + bytesIdx,
+              codePoint & 0xffn,
+              _BYTES_DATA_OFFSET
+            )
             WasmI32.store8(
               bytes + bytesIdx + 1n,
               (codePoint & 0xff00n) >>> 8n,
-              _BYTES_OFFSET
+              _BYTES_DATA_OFFSET
             )
             WasmI32.store8(
               bytes + bytesIdx + 2n,
               (codePoint & 0xff0000n) >>> 16n,
-              _BYTES_OFFSET
+              _BYTES_DATA_OFFSET
             )
             WasmI32.store8(
               bytes + bytesIdx + 3n,
               (codePoint & 0xff000000n) >>> 24n,
-              _BYTES_OFFSET
+              _BYTES_DATA_OFFSET
             )
             bytesIdx += 4n
           },
@@ -1446,8 +1314,7 @@ let encodeHelp = (string: String, encoding: Encoding, includeBom: Bool) => {
   } else {
     0
   })
-  use WasmI32.{ (>>>) }
-  let bytes = WasmI32.toGrain(allocateBytes(WasmI32.fromGrain(size) >>> 1n))
+  let bytes = WasmI32.toGrain(allocateBytes(untagSimpleNumber(size)))
   encodeAtHelp(string, encoding, includeBom, bytes, 0)
 }
 
@@ -1468,92 +1335,42 @@ provide let encode = (string: String, encoding: Encoding, includeBom=false) => {
 
 // Byte->String decoding and helper functions:
 
-@unsafe
-let writeUtf8CodePoint = (ptr, codePoint) => {
-  use WasmI32.{ (+), (-), (&), (|), (>>>), ltU as (<), leU as (<=), (==) }
-  if (codePoint <= 0x007Fn) {
-    // Code points in the ASCII range are written as just one byte with the
-    // leading bit equal to zero (0xxxxxxx). Just store the value as one byte
-    // directly. Note that the value is already guaranteed to start with most
-    // significant bit equal to zero because of the check in the if statement
-    // above, so there's no need to bit-mask it.
-    WasmI32.store8(ptr, codePoint, 0n)
-    1n
-  } else if (codePoint <= 0x07FFn) {
-    // Code points in the range 0x0080..0x07FF are written as two bytes.
-    // 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
-    WasmI32.store8(ptr, high, 0n)
-    WasmI32.store8(ptr + 1n, low, 0n)
-    2n
-  } else if (codePoint <= 0xFFFFn) {
-    // Code points in the range 0x0800..0xFFFF are written as three bytes.
-    // 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
-    WasmI32.store8(ptr, high, 0n)
-    WasmI32.store8(ptr + 1n, mid, 0n)
-    WasmI32.store8(ptr + 2n, low, 0n)
-    3n
-  } else {
-    // Code points in the range 0x10000..0x10FFFF are written as four bytes.
-    // 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
-    WasmI32.store8(ptr, high, 0n)
-    WasmI32.store8(ptr + 1n, mid1, 0n)
-    WasmI32.store8(ptr + 2n, mid2, 0n)
-    WasmI32.store8(ptr + 3n, low, 0n)
-    4n
-  }
-}
-
 @unsafe
 let bytesHaveBom = (bytes: Bytes, encoding: Encoding, start: WasmI32) => {
   use WasmI32.{ (+), geU as (>=), (==) }
   let ptr = WasmI32.fromGrain(bytes)
-  let bytesSize = WasmI32.load(ptr, 4n)
+  let bytesSize = WasmI32.load(ptr, _BYTES_LEN_OFFSET)
   let ptr = ptr + start
   let result = 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_DATA_OFFSET) == 0xEFn
+        && WasmI32.load8U(ptr + 1n, _BYTES_DATA_OFFSET) == 0xBBn
+        && WasmI32.load8U(ptr + 2n, _BYTES_DATA_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_DATA_OFFSET) == 0xFEn
+        && WasmI32.load8U(ptr + 1n, _BYTES_DATA_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_DATA_OFFSET) == 0xFFn
+        && WasmI32.load8U(ptr + 1n, _BYTES_DATA_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_DATA_OFFSET) == 0x00n
+        && WasmI32.load8U(ptr + 1n, _BYTES_DATA_OFFSET) == 0x00n
+        && WasmI32.load8U(ptr + 2n, _BYTES_DATA_OFFSET) == 0xFEn
+        && WasmI32.load8U(ptr + 3n, _BYTES_DATA_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_DATA_OFFSET) == 0xFFn
+        && WasmI32.load8U(ptr + 1n, _BYTES_DATA_OFFSET) == 0xFEn
+        && WasmI32.load8U(ptr + 2n, _BYTES_DATA_OFFSET) == 0x00n
+        && WasmI32.load8U(ptr + 3n, _BYTES_DATA_OFFSET) == 0x00n
     },
   }
 
@@ -1585,14 +1402,14 @@ let decodedLength = (
   }
   let ptr = WasmI32.fromGrain(bytes)
   let bytesSize = {
-    let tmp = WasmI32.load(ptr, 4n) - start
+    let tmp = WasmI32.load(ptr, _BYTES_LEN_OFFSET) - start
     if (size < tmp) {
       size
     } else {
       tmp
     }
   }
-  let start = ptr + _BYTES_OFFSET + start
+  let start = ptr + _BYTES_DATA_OFFSET + start
   let result = match (encoding) {
     UTF8 => bytesSize,
     UTF16_BE => {
@@ -1606,8 +1423,8 @@ let decodedLength = (
           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
@@ -1624,15 +1441,7 @@ let decodedLength = (
           ptr += 2n
           codeWord
         }
-        if (codeWord <= 0x007Fn) {
-          count += 1n
-        } else if (codeWord <= 0x07FFn) {
-          count += 2n
-        } else if (codeWord <= 0xFFFFn) {
-          count += 3n
-        } else {
-          count += 4n
-        }
+        count += usvEncodeLength(codeWord)
       }
       count
     },
@@ -1647,8 +1456,8 @@ let decodedLength = (
           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
@@ -1665,15 +1474,7 @@ let decodedLength = (
           ptr += 2n
           codeWord
         }
-        if (codeWord <= 0x007Fn) {
-          count += 1n
-        } else if (codeWord <= 0x07FFn) {
-          count += 2n
-        } else if (codeWord <= 0xFFFFn) {
-          count += 3n
-        } else {
-          count += 4n
-        }
+        count += usvEncodeLength(codeWord)
       }
       count
     },
@@ -1686,20 +1487,12 @@ let decodedLength = (
       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
-        } else if (codeWord <= 0x07FFn) {
-          count += 2n
-        } else if (codeWord <= 0xFFFFn) {
-          count += 3n
-        } else {
-          count += 4n
-        }
+        count += usvEncodeLength(codeWord)
       }
       count
     },
@@ -1712,20 +1505,12 @@ let decodedLength = (
       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
-        } else if (codeWord <= 0x07FFn) {
-          count += 2n
-        } else if (codeWord <= 0xFFFFn) {
-          count += 3n
-        } else {
-          count += 4n
-        }
+        count += usvEncodeLength(codeWord)
       }
       count
     },
@@ -1764,15 +1549,15 @@ let decodeRangeHelp = (
   let str = allocateString(stringSize)
   let mut bytesPtr = WasmI32.fromGrain(bytes)
   let bytesSize = {
-    let tmp = WasmI32.load(bytesPtr, 4n) - start
+    let tmp = WasmI32.load(bytesPtr, _BYTES_LEN_OFFSET) - start
     if (size < tmp) {
       size
     } else {
       tmp
     }
   }
-  bytesPtr += _BYTES_OFFSET + start
-  let mut strPtr = str + 8n
+  bytesPtr += _BYTES_DATA_OFFSET + start
+  let mut strPtr = str + _STR_DATA_OFFSET
   let mut bomRead = false
   if (skipBom && hasBom) {
     bytesPtr += match (encoding) {
@@ -1794,16 +1579,16 @@ let decodeRangeHelp = (
         // 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
+              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
@@ -1819,16 +1604,16 @@ let decodeRangeHelp = (
         // 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
+              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
@@ -1846,10 +1631,10 @@ let decodeRangeHelp = (
       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)
         }
@@ -1857,10 +1642,10 @@ let decodeRangeHelp = (
       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)
         }
@@ -1944,26 +1729,18 @@ provide let decode = (bytes: Bytes, encoding: Encoding, keepBom=false) => {
  */
 @unsafe
 provide let forEachCodePoint = (fn: Number => Void, str: String) => {
-  use WasmI32.{ (+), (-), (&), (>>>), ltU as (<), leU as (<=), (==) }
+  use WasmI32.{ (+), ltU as (<) }
 
   let strPtr = WasmI32.fromGrain(str)
 
-  let byteSize = WasmI32.load(strPtr, 4n)
+  let byteSize = rawByteLength(strPtr)
 
-  let mut ptr = strPtr + 8n
+  let mut ptr = strPtr + _STR_DATA_OFFSET
   let end = ptr + byteSize
 
   while (ptr < end) {
     let byte = WasmI32.load8U(ptr, 0n)
-    let codePointByteCount = if ((byte & 0x80n) == 0x00n) {
-      1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      3n
-    } else {
-      2n
-    }
+    let codePointByteCount = utf8ByteCount(byte)
 
     // Note that even if up to 4 bytes are needed to represent Unicode
     // codepoints, this doesn't mean 32 bits. The highest allowed code point is
@@ -1997,27 +1774,19 @@ provide let forEachCodePoint = (fn: Number => Void, str: String) => {
  */
 @unsafe
 provide let forEachCodePointi = (fn: (Number, Number) => Void, str: String) => {
-  use WasmI32.{ (+), (-), (&), (>>>), ltU as (<), leU as (<=), (==) }
+  use WasmI32.{ (+), ltU as (<), (==) }
 
   let strPtr = WasmI32.fromGrain(str)
 
-  let byteSize = WasmI32.load(strPtr, 4n)
+  let byteSize = rawByteLength(strPtr)
 
-  let mut ptr = strPtr + 8n
+  let mut ptr = strPtr + _STR_DATA_OFFSET
   let end = ptr + byteSize
 
   let mut idx = 0n
   while (ptr < end) {
     let byte = WasmI32.load8U(ptr, 0n)
-    let codePointByteCount = if ((byte & 0x80n) == 0x00n) {
-      1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      3n
-    } else {
-      2n
-    }
+    let codePointByteCount = utf8ByteCount(byte)
 
     // Note that even if up to 4 bytes are needed to represent Unicode
     // codepoints, this doesn't mean 32 bits. The highest allowed code point is
@@ -2050,26 +1819,18 @@ provide let forEachCodePointi = (fn: (Number, Number) => Void, str: String) => {
  */
 @unsafe
 provide let forEachChar = (fn: Char => Void, str: String) => {
-  use WasmI32.{ (+), (-), (&), (>>>), ltU as (<), leU as (<=), (==) }
+  use WasmI32.{ (+), ltU as (<), (==) }
 
   let strPtr = WasmI32.fromGrain(str)
 
-  let byteSize = WasmI32.load(strPtr, 4n)
+  let byteSize = rawByteLength(strPtr)
 
-  let mut ptr = strPtr + 8n
+  let mut ptr = strPtr + _STR_DATA_OFFSET
   let end = ptr + byteSize
 
   while (ptr < end) {
     let byte = WasmI32.load8U(ptr, 0n)
-    let codePointByteCount = if ((byte & 0x80n) == 0x00n) {
-      1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      3n
-    } else {
-      2n
-    }
+    let codePointByteCount = utf8ByteCount(byte)
 
     // Note that even if up to 4 bytes are needed to represent Unicode
     // codepoints, this doesn't mean 32 bits. The highest allowed code point is
@@ -2100,27 +1861,19 @@ provide let forEachChar = (fn: Char => Void, str: String) => {
  */
 @unsafe
 provide let forEachChari = (fn: (Char, Number) => Void, str: String) => {
-  use WasmI32.{ (+), (-), (&), (>>>), ltU as (<), leU as (<=), (==) }
+  use WasmI32.{ (+), ltU as (<), (==) }
 
   let strPtr = WasmI32.fromGrain(str)
 
-  let byteSize = WasmI32.load(strPtr, 4n)
+  let byteSize = rawByteLength(strPtr)
 
-  let mut ptr = strPtr + 8n
+  let mut ptr = strPtr + _STR_DATA_OFFSET
   let end = ptr + byteSize
 
   let mut idx = 0n
   while (ptr < end) {
     let byte = WasmI32.load8U(ptr, 0n)
-    let codePointByteCount = if ((byte & 0x80n) == 0x00n) {
-      1n
-    } else if ((byte & 0xF0n) == 0xF0n) {
-      4n
-    } else if ((byte & 0xE0n) == 0xE0n) {
-      3n
-    } else {
-      2n
-    }
+    let codePointByteCount = utf8ByteCount(byte)
 
     // Note that even if up to 4 bytes are needed to represent Unicode
     // codepoints, this doesn't mean 32 bits. The highest allowed code point is
@@ -2194,7 +1947,8 @@ let trimString = (stringPtr: WasmI32, byteLength: WasmI32, fromEnd: Bool) => {
     // TODO(#661): Use unicode whitespace property and unicode line terminator
     if (!fromEnd) {
       if (
-        byte == 0xEFn && // Check for the first BOM byte
+        byte == 0xEFn
+        && // Check for the first BOM byte
         // Check for the full BOM codepoint, 0xEFBBBF. Bytes are reversed because wasm is little-endian
         WasmI32.load(stringPtr, i - 1n) >>> 8n == 0xBFBBEFn
       ) {
@@ -2204,7 +1958,8 @@ let trimString = (stringPtr: WasmI32, byteLength: WasmI32, fromEnd: Bool) => {
       }
     } else {
       if (
-        byte == 0xBFn && // Check for the last BOM byte
+        byte == 0xBFn
+        && // Check for the last BOM byte
         // Check for the full BOM codepoint, 0xEFBBBF. Bytes are reversed because wasm is little-endian
         WasmI32.load(stringPtr, i - 3n) >>> 8n == 0xBFBBEFn
       ) {
@@ -2214,12 +1969,18 @@ let trimString = (stringPtr: WasmI32, byteLength: WasmI32, fromEnd: Bool) => {
       }
     }
     if (
-      byte != 0x20n && // Space
-      byte != 0x0Dn && // LF
-      byte != 0x0An && // CR
-      byte != 0x09n && // Tab
-      byte != 0x0Bn && // LINE TABULATION
-      byte != 0x0Cn && // FORM FEED (FF)
+      byte != 0x20n
+      && // Space
+      byte != 0x0Dn
+      && // LF
+      byte != 0x0An
+      && // CR
+      byte != 0x09n
+      && // Tab
+      byte != 0x0Bn
+      && // LINE TABULATION
+      byte != 0x0Cn
+      && // FORM FEED (FF)
       byte != 0xA0n // No Break Space
     ) {
       break
@@ -2242,11 +2003,11 @@ let trimString = (stringPtr: WasmI32, byteLength: WasmI32, fromEnd: Bool) => {
 provide let trimStart = (string: String) => {
   use WasmI32.{ (-), (+) }
   let mut stringPtr = WasmI32.fromGrain(string)
-  let byteLength = WasmI32.load(stringPtr, 4n)
-  stringPtr += 8n
+  let byteLength = rawByteLength(stringPtr)
+  stringPtr += _STR_DATA_OFFSET
   let count = trimString(stringPtr, byteLength, false)
   let str = allocateString(byteLength - count)
-  Memory.copy(str + 8n, stringPtr + count, byteLength - count)
+  Memory.copy(str + _STR_DATA_OFFSET, stringPtr + count, byteLength - count)
   ignore(string)
   WasmI32.toGrain(str): String
 }
@@ -2264,11 +2025,11 @@ provide let trimStart = (string: String) => {
 provide let trimEnd = (string: String) => {
   use WasmI32.{ (-), (+) }
   let mut stringPtr = WasmI32.fromGrain(string)
-  let byteLength = WasmI32.load(stringPtr, 4n)
-  stringPtr += 8n
+  let byteLength = rawByteLength(stringPtr)
+  stringPtr += _STR_DATA_OFFSET
   let count = trimString(stringPtr, byteLength, true)
   let str = allocateString(byteLength - count)
-  Memory.copy(str + 8n, stringPtr, byteLength - count)
+  Memory.copy(str + _STR_DATA_OFFSET, stringPtr, byteLength - count)
   ignore(string)
   WasmI32.toGrain(str): String
 }
@@ -2286,14 +2047,14 @@ provide let trimEnd = (string: String) => {
 provide let trim = (string: String) => {
   use WasmI32.{ (-), (+), (==) }
   let mut stringPtr = WasmI32.fromGrain(string)
-  let byteLength = WasmI32.load(stringPtr, 4n)
-  stringPtr += 8n
+  let byteLength = rawByteLength(stringPtr)
+  stringPtr += _STR_DATA_OFFSET
   let startCount = trimString(stringPtr, byteLength, false)
   if (startCount == byteLength) return ""
   let endCount = trimString(stringPtr, byteLength, true)
   let str = allocateString(byteLength - startCount - endCount)
   Memory.copy(
-    str + 8n,
+    str + _STR_DATA_OFFSET,
     stringPtr + startCount,
     byteLength - startCount - endCount
   )
@@ -2315,7 +2076,7 @@ provide let toAsciiLowercase = string => {
   let chars = explode(string)
   let len = arrayLength(chars)
   for (let mut i = 0; i < len; i += 1) {
-    chars[i] = Char.toAsciiLowercase(chars[i])
+    chars[i] = Char.Ascii.toLowercase(chars[i])
   }
   implode(chars)
 }
@@ -2334,7 +2095,41 @@ provide let toAsciiUppercase = string => {
   let chars = explode(string)
   let len = arrayLength(chars)
   for (let mut i = 0; i < len; i += 1) {
-    chars[i] = Char.toAsciiUppercase(chars[i])
+    chars[i] = Char.Ascii.toUppercase(chars[i])
   }
   implode(chars)
 }
+
+/**
+ * Produces a new string by repeating a substring a given number of times.
+ *
+ * @param count: The number of times to repeat the string
+ * @param string: The string to repeat
+ * @returns A string containing the repeated input string
+ *
+ * @throws InvalidArgument(String): When the `count` is not an integer
+ * @throws InvalidArgument(String): When the `count` is negative
+ *
+ * @example assert String.repeat(5, "=") == "====="
+ * @example assert String.repeat(0, ".") == ""
+ *
+ * @since v0.6.7
+ */
+@unsafe
+provide let repeat = (count, string: String) => {
+  use WasmI32.{ (+), (*), (<), (&), (!=) }
+  let rawCount = convSimpleNumber(count, "Invalid count value")
+  if (rawCount < 0n) {
+    throw InvalidArgument("Invalid count must be a positive integer or zero")
+  }
+  let stringPtr = WasmI32.fromGrain(string)
+  let byteLength = rawByteLength(stringPtr)
+  let stringPtr = stringPtr + _STR_DATA_OFFSET
+  let newStringPtr = allocateString(byteLength * rawCount)
+  let strContentPtr = newStringPtr + _STR_DATA_OFFSET
+  for (let mut i = 0n; i < rawCount; i += 1n) {
+    Memory.copy(strContentPtr + byteLength * i, stringPtr, byteLength)
+  }
+  ignore(string)
+  return WasmI32.toGrain(newStringPtr): String
+}