json-as 0.9.28 → 1.0.0-alpha.1

package/assembly/deserialize/simple/array/float.ts

@@ -0,0 +1,28 @@
+import { isSpace } from "../../../util";
+import { COMMA, BRACE_RIGHT, BRACKET_RIGHT } from "../../../custom/chars";
+import { JSON } from "../../..";
+
+export function deserializeFloatArray<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = dst ? changetype<T>(dst) : instantiate<T>();
+  let lastIndex: usize = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code - 48 <= 9 || code == 45) {
+      lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
+          out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          break;
+        }
+        srcStart += 2;
+      }
+    }
+    srcStart += 2;
+  }
+  return out;
+}

package/assembly/deserialize/simple/array/integer.ts

@@ -0,0 +1,27 @@
+import { atoi, isSpace } from "../../../util";
+import { COMMA, BRACKET_RIGHT } from "../../../custom/chars";
+
+export function deserializeIntegerArray<T extends number[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out: T = dst ? changetype<T>(dst) : instantiate<T>();
+  let lastIndex: usize = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code - 48 <= 9 || code == 45) {
+      lastIndex = srcStart;
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
+          out.push(atoi<valueof<T>>(lastIndex, srcStart));
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          break;
+        }
+        srcStart += 2;
+      }
+    }
+    srcStart += 2;
+  }
+  return out;
+}

package/assembly/deserialize/simple/array/map.ts

@@ -0,0 +1,18 @@
+import { BRACE_LEFT, BRACE_RIGHT } from "../../../custom/chars";
+import { JSON } from "../../..";
+
+export function deserializeMapArray<T extends Map<any, any>[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = dst ? changetype<T>(dst) : instantiate<T>();
+  let lastIndex: usize = 0;
+  let depth: u32 = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == BRACE_LEFT && depth++ == 0) {
+      lastIndex = srcStart;
+    } else if (code == BRACE_RIGHT && --depth == 0) {
+      out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+    }
+    srcStart += 2;
+  }
+  return out;
+}

package/assembly/deserialize/simple/array/object.ts

@@ -0,0 +1,18 @@
+import { BRACE_LEFT, BRACE_RIGHT } from "../../../custom/chars";
+import { JSON } from "../../..";
+
+export function deserializeObjectArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = dst ? changetype<T>(dst) : instantiate<T>();
+  let lastIndex: usize = 0;
+  let depth: u32 = 0;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == BRACE_LEFT && depth++ == 0) {
+      lastIndex = srcStart;
+    } else if (code == BRACE_RIGHT && --depth == 0) {
+      out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+    }
+    srcStart += 2;
+  }
+  return out;
+}

package/assembly/deserialize/simple/array/string.ts

@@ -0,0 +1,22 @@
+import { JSON } from "../../..";
+import { BACK_SLASH, QUOTE } from "../../../custom/chars";
+
+export function deserializeStringArray(srcStart: usize, srcEnd: usize, dst: usize): string[] {
+  const out = dst ? changetype<string[]>(dst) : new Array<string>();
+  let lastPos = 2;
+  let inString = false;
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == QUOTE) {
+      if (!inString) {
+        inString = true;
+        lastPos = srcStart;
+      } else if (load<u16>(srcStart - 2) != BACK_SLASH) {
+        out.push(JSON.__deserialize<string>(lastPos, srcStart));
+        inString = false;
+      }
+    }
+    srcStart += 2;
+  }
+  return out;
+}

package/assembly/deserialize/simple/array.ts

@@ -0,0 +1,48 @@
+import { JSON } from "../..";
+import { deserializeArbitraryArray } from "./array/arbitrary";
+import { deserializeArrayArray } from "./array/array";
+import { deserializeBooleanArray } from "./array/bool";
+import { deserializeFloatArray } from "./array/float";
+import { deserializeIntegerArray } from "./array/integer";
+import { deserializeMapArray } from "./array/map";
+import { deserializeObjectArray } from "./array/object";
+import { deserializeStringArray } from "./array/string";
+
+// @ts-ignore: Decorator valid here
+export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  if (isString<valueof<T>>()) {
+    return <T>deserializeStringArray(srcStart, srcEnd, dst);
+  } else if (isBoolean<valueof<T>>()) {
+    // @ts-ignore
+    return deserializeBooleanArray<T>(srcStart, srcEnd, dst);
+  } else if (isInteger<valueof<T>>()) {
+    // @ts-ignore
+    return deserializeIntegerArray<T>(srcStart, srcEnd, dst);
+  } else if (isFloat<valueof<T>>()) {
+    // @ts-ignore
+    return deserializeFloatArray<T>(srcStart, srcEnd, dst);
+  } else if (isArrayLike<valueof<T>>()) {
+    // @ts-ignore: type
+    return deserializeArrayArray<T>(srcStart, srcEnd, dst);
+  } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+    const type = changetype<nonnull<valueof<T>>>(0);
+    if (type instanceof JSON.Value) {
+      // @ts-ignore: type
+      return deserializeArbitraryArray<T>(srcStart, srcEnd, dst);
+    } else if (type instanceof Map) {
+      // @ts-ignore: type
+      return deserializeMapArray<T>(srcStart, srcEnd, dst);
+      // @ts-ignore: defined by transform
+    } else if (isDefined(type.__DESERIALIZE)) {
+      return deserializeObjectArray<T>(srcStart, srcEnd, dst);
+    }
+    throw new Error("Could not parse array of type " + nameof<T>() + "!");
+  } else {
+    throw new Error("Could not parse array of type " + nameof<T>() + "!");
+  }
+}
+
+function isMap<T>(): boolean {
+  let type: T = changetype<T>(0);
+  return type instanceof Map;
+}

package/assembly/deserialize/simple/bool.ts

@@ -0,0 +1,9 @@
+import { CHAR_F, CHAR_T } from "../../custom/chars";
+
+export function deserializeBoolean(srcStart: usize, srcEnd: usize): boolean {
+  const srcSize = srcEnd - srcStart;
+  const firstChar = load<u16>(srcStart);
+  if (firstChar == CHAR_T && load<u64>(srcStart) == 28429475166421108) return true;
+  else if (firstChar == CHAR_F && load<u64>(srcSize, 2) == 28429466576093281) return false;
+  return false; //ERROR(`Expected to find boolean, but found "${data.slice(0, 100)}" instead!`);
+}

package/assembly/deserialize/simple/date.ts

@@ -0,0 +1,11 @@
+import { ptrToStr } from "../../util/ptrToStr";
+
+export function deserializeDate(srcStart: usize, srcEnd: usize): Date {
+  // Use AssemblyScript's date parser
+  const d = Date.fromString(ptrToStr(srcStart, srcEnd));
+
+  // Return a new object instead of the one that the parser returned.
+  // This may seem redundant, but addreses the issue when Date
+  // is globally aliased to wasi_Date (or some other superclass).
+  return new Date(d.getTime());
+}

package/assembly/deserialize/simple/float.ts

@@ -0,0 +1,10 @@
+import { ptrToStr } from "../../util/ptrToStr";
+
+export function deserializeFloat<T>(srcStart: usize, srcEnd: usize): T {
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return f64.parse(ptrToStr(srcStart, srcEnd));
+  // @ts-ignore
+  return f32.parse(ptrToStr(srcStart, srcEnd));
+}

package/assembly/deserialize/simple/integer.ts

@@ -0,0 +1,5 @@
+import { atoi } from "../../util/atoi";
+
+export function deserializeInteger<T>(srcStart: usize, srcEnd: usize): T {
+  return atoi<T>(srcStart, srcEnd);
+}

package/assembly/deserialize/simple/map.ts

@@ -0,0 +1,154 @@
+import { JSON } from "../..";
+import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T, COLON } from "../../custom/chars";
+import { isSpace } from "../../util";
+
+export function deserializeMap<T extends Map<any, any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = changetype<T>(dst || __new(offsetof<T>(), idof<T>()));
+  // @ts-ignore: type
+  if (!isString<indexof<T>>() && !isInteger<indexof<T>>() && !isFloat<indexof<T>>()) ERROR("Map key must also be a valid JSON key!");
+
+  const srcPtr = srcStart;
+  let key: string | null = null;
+  let isKey = false;
+  let depth = 0;
+  let lastIndex = 0;
+
+  // while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  // while (srcEnd > srcStart && isSpace(load<u16>(srcEnd))) srcEnd -= 2;
+
+  while (srcStart < srcEnd) {
+    let code = load<u16>(srcStart); // while (isSpace(code)) code = load<u16>(srcStart += 2);
+    if (key == null) {
+      if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
+        if (isKey) {
+          key = sliceTo(lastIndex, srcStart);
+          while (isSpace((code = load<u16>((srcStart += 2))))) {
+            /* empty */
+          }
+          if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcStart - srcPtr).toString());
+          isKey = false;
+        } else {
+          isKey = true;
+          lastIndex = srcStart + 2;
+        }
+      }
+      // isKey = !isKey;
+      srcStart += 2;
+    } else {
+      // @ts-ignore: type
+      if (isString<valueof<T>>() && code == QUOTE) {
+        lastIndex = srcStart;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const code = load<u16>(srcStart);
+          if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
+            while (isSpace(load<u16>((srcStart += 2)))) {
+              /* empty */
+            }
+            // @ts-ignore: type
+            out.set(key, JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            key = null;
+            break;
+          }
+          srcStart += 2;
+        }
+        // @ts-ignore: type
+      } else if ((!isBoolean<valueof<T>>() && isInteger<valueof<T>>() && code - 48 <= 9) || code == 45) {
+        lastIndex = srcStart;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const code = load<u16>(srcStart);
+          if (code == COMMA || isSpace(code) || code == BRACE_RIGHT) {
+            // @ts-ignore: type
+            out.set(key, JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            while (isSpace(load<u16>((srcStart += 2)))) {
+              /* empty */
+            }
+            key = null;
+            break;
+          }
+          srcStart += 2;
+        }
+        // @ts-ignore: type
+      } else if (isArray<valueof<T>>() && code == BRACKET_LEFT) {
+        lastIndex = srcStart;
+        depth++;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const code = load<u16>(srcStart);
+          if (((code ^ BRACE_RIGHT) | (code ^ BRACKET_RIGHT)) == 32) {
+            if (--depth == 0) {
+              // @ts-ignore: type
+              out.set(key, JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+              while (isSpace(load<u16>((srcStart += 2)))) {
+                /* empty */
+              }
+              key = null;
+              break;
+            }
+          } else if (code == BRACKET_LEFT) depth++;
+          srcStart += 2;
+        }
+        // @ts-ignore: type
+      } else if (isDefined(changetype<nonnull<valueof<T>>>(0).__DESERIALIZE) && code == BRACE_LEFT) {
+        lastIndex = srcStart;
+        depth++;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const code = load<u16>(srcStart);
+          if (code == BRACE_RIGHT) {
+            if (--depth == 0) {
+              // @ts-ignore: type
+              out.set(key, JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+              while (isSpace(load<u16>((srcStart += 2)))) {
+                /* empty */
+              }
+              key = null;
+              break;
+            }
+          } else if (code == BRACE_LEFT) depth++;
+          srcStart += 2;
+        }
+        // @ts-ignore: type
+      } else if (isBoolean<valueof<T>>() && code == CHAR_T) {
+        if (load<u64>(srcStart) == 28429475166421108) {
+          // @ts-ignore: type
+          out.set(key, JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
+          while (isSpace(load<u16>((srcStart += 2)))) {
+            /* empty */
+          }
+          key = null;
+        }
+        // @ts-ignore: type
+      } else if (isBoolean<valueof<T>>() && code == CHAR_F) {
+        if (load<u64>(srcStart, 2) == 28429466576093281) {
+          // @ts-ignore: type
+          out.set(key, JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 10)));
+          while (isSpace(load<u16>((srcStart += 2)))) {
+            /* empty */
+          }
+          key = null;
+        }
+      } else if ((isNullable<T>() || nameof<T>() == "usize") && code == CHAR_N) {
+        if (load<u64>(srcStart) == 30399761348886638) {
+          // @ts-ignore: type
+          out.set(key, JSON.__deserialize<valueof<T>>(srcStart, (srcStart += 8)));
+          while (isSpace(load<u16>((srcStart += 2)))) {
+            /* empty */
+          }
+        }
+      } else {
+        // @ts-ignore: type
+        throw new Error("Unexpected character " + String.fromCharCode(code) + " or type " + nameof<valueof<T>>() + " does not match found type!");
+      }
+    }
+  }
+  return out;
+}
+
+function sliceTo(srcStart: usize, srcEnd: usize): string {
+  const dstSize = srcEnd - srcStart;
+  const dst = __new(dstSize, idof<string>());
+  memory.copy(dst, srcStart, dstSize);
+  return changetype<string>(dst);
+}

package/assembly/deserialize/simple/object.ts

@@ -0,0 +1,159 @@
+import { BACK_SLASH, COMMA, CHAR_F, BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE, BRACE_RIGHT, BRACKET_RIGHT, CHAR_T, COLON } from "../../custom/chars";
+import { isSpace } from "../../util";
+import { ptrToStr } from "../../util/ptrToStr";
+
+export function deserializeObject<T>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  const out = changetype<nonnull<T>>(dst || __new(offsetof<T>(), idof<T>()));
+
+  let keyStart: usize = 0;
+  let keyEnd: usize = 0;
+  let isKey = false;
+  let depth = 0;
+  let lastIndex = 0;
+
+  // while (srcStart < srcEnd && isSpace(load<u16>(srcStart))) srcStart += 2;
+  // while (srcEnd > srcStart && isSpace(load<u16>(srcEnd))) srcEnd -= 2;
+  srcStart += 2;
+  while (srcStart < srcEnd) {
+    let code = load<u16>(srcStart); // while (isSpace(code)) code = load<u16>(srcStart += 2);
+    if (keyStart == 0) {
+      if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
+        if (isKey) {
+          keyStart = lastIndex;
+          keyEnd = srcStart;
+          // console.log("Key: " + ptrToStr(lastIndex, srcStart));
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart + 2)));
+          srcStart += 2;
+          // while (isSpace((code = load<u16>((srcStart += 2))))) {
+          //   /* empty */
+          // }
+          // if (code !== COLON) throw new Error("Expected ':' after key at position " + (srcStart - srcPtr).toString());
+          isKey = false;
+        } else {
+          // console.log("Got key start");
+          isKey = true; // i don't like this
+          lastIndex = srcStart + 2;
+        }
+      }
+      // isKey = !isKey;
+      srcStart += 2;
+    } else {
+      if (code == QUOTE) {
+        lastIndex = srcStart;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const code = load<u16>(srcStart);
+          if (code == QUOTE && load<u16>(srcStart - 2) !== BACK_SLASH) {
+            // console.log("Value (string): " + ptrToStr(lastIndex, srcStart + 2));
+            // @ts-ignore: exists
+            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart + 2, dst);
+            // while (isSpace(load<u16>(srcStart))) srcStart += 2;
+            srcStart += 4;
+            // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+            keyStart = 0;
+            break;
+          }
+          srcStart += 2;
+        }
+      } else if (code - 48 <= 9 || code == 45) {
+        lastIndex = srcStart;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const code = load<u16>(srcStart);
+          if (code == COMMA || code == BRACE_RIGHT || isSpace(code)) {
+            // @ts-ignore: exists
+            out.__DESERIALIZE(keyStart, keyEnd, lastIndex, srcStart, dst);
+            // console.log("Value (number): " + ptrToStr(lastIndex, srcStart));
+            // while (isSpace(load<u16>((srcStart += 2)))) {
+            //   /* empty */
+            // }
+            srcStart += 2;
+            // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+            keyStart = 0;
+            break;
+          }
+          srcStart += 2;
+        }
+      } else if (code == BRACE_LEFT) {
+        lastIndex = srcStart;
+        depth++;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const code = load<u16>(srcStart);
+          if (code == BRACE_RIGHT) {
+            if (--depth == 0) {
+              // console.log("Value (object): " + ptrToStr(lastIndex, srcStart + 2));
+              // @ts-ignore: exists
+              out.__DESERIALIZE(keyStart, keyEnd, lastIndex, (srcStart += 2), dst);
+              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+              keyStart = 0;
+              // while (isSpace(load<u16>(srcStart))) {
+              //   /* empty */
+              // }
+              break;
+            }
+          } else if (code == BRACE_LEFT) depth++;
+          srcStart += 2;
+        }
+      } else if (code == BRACKET_LEFT) {
+        lastIndex = srcStart;
+        depth++;
+        srcStart += 2;
+        while (srcStart < srcEnd) {
+          const code = load<u16>(srcStart);
+          if (code == BRACKET_RIGHT) {
+            if (--depth == 0) {
+              // console.log("Value (array): " + ptrToStr(lastIndex, srcStart + 2));
+              // @ts-ignore: exists
+              out.__DESERIALIZE(keyStart, keyEnd, lastIndex, (srcStart += 2), dst);
+              // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+              keyStart = 0;
+              // while (isSpace(load<u16>((srcStart += 2)))) {
+              //   /* empty */
+              // }
+              break;
+            }
+          } else if (code == BRACKET_LEFT) depth++;
+          srcStart += 2;
+        }
+      } else if (code == CHAR_T) {
+        if (load<u64>(srcStart) == 28429475166421108) {
+          // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 8));
+          // @ts-ignore: exists
+          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), dst);
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          srcStart += 2;
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)) + "  " + (srcStart < srcEnd).toString());
+          keyStart = 0;
+        }
+      } else if (code == CHAR_F) {
+        if (load<u64>(srcStart, 2) == 28429466576093281) {
+          // console.log("Value (bool): " + ptrToStr(srcStart, srcStart + 10));
+          // @ts-ignore: exists
+          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 10), dst);
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          //   /* empty */
+          // }
+          srcStart += 2;
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+          keyStart = 0;
+        }
+      } else if (code == CHAR_N) {
+        if (load<u64>(srcStart) == 30399761348886638) {
+          // console.log("Value (null): " + ptrToStr(srcStart, srcStart + 8));
+          // @ts-ignore: exists
+          out.__DESERIALIZE(keyStart, keyEnd, srcStart, (srcStart += 8), dst);
+          // while (isSpace(load<u16>((srcStart += 2)))) {
+          /* empty */
+          // }
+          srcStart += 2;
+          // console.log("Next: " + String.fromCharCode(load<u16>(srcStart)));
+          keyStart = 0;
+        }
+      }
+    }
+  }
+  return out;
+}

package/assembly/deserialize/simple/string.ts

@@ -0,0 +1,48 @@
+import { BACK_SLASH } from "../../custom/chars";
+import { DESERIALIZE_ESCAPE_TABLE, ESCAPE_HEX_TABLE } from "../../globals/tables";
+
+export function deserializeString(srcStart: usize, srcEnd: usize, dst: usize): string {
+  srcStart += 2;
+  srcEnd -= 2;
+  if (dst == 0) dst = __new(srcEnd - srcStart, idof<string>());
+  let dstPtr = dst;
+  let lastPtr = srcStart;
+  while (srcStart < srcEnd) {
+    let code = load<u16>(srcStart);
+    if (code == BACK_SLASH) {
+      code = load<u16>(DESERIALIZE_ESCAPE_TABLE + load<u8>(srcStart, 2));
+      if (code == 117 && load<u32>(srcStart, 4) == 3145776) {
+        const block = load<u32>(srcStart, 8);
+        const codeA = block & 0xffff;
+        const codeB = (block >> 16) & 0xffff;
+        const escapedA = load<u8>(ESCAPE_HEX_TABLE + codeA);
+        const escapedB = load<u8>(ESCAPE_HEX_TABLE + codeB);
+        const escaped = (escapedA << 4) + escapedB;
+        const remBytes = srcStart - lastPtr;
+        memory.copy(dstPtr, lastPtr, remBytes);
+        dstPtr += remBytes;
+        store<u16>(dst, escaped);
+        dstPtr += 2;
+        srcStart += 12;
+        lastPtr = srcStart;
+      } else {
+        const remBytes = srcStart - lastPtr;
+        memory.copy(dstPtr, lastPtr, remBytes);
+        dstPtr += remBytes;
+        store<u16>(dstPtr, code);
+        dstPtr += 2;
+        srcStart += 4;
+        lastPtr = srcStart;
+      }
+    } else {
+      srcStart += 2;
+    }
+  }
+
+  const remBytes = srcEnd - lastPtr;
+  memory.copy(dstPtr, lastPtr, remBytes);
+  dstPtr += remBytes;
+
+  if (lastPtr != srcStart) dst = __renew(dst, dstPtr - dst);
+  return changetype<string>(dst);
+}