json-as 0.9.29 → 1.0.0-alpha.1

package/assembly/serialize/simple/arbitrary.ts

@@ -0,0 +1,36 @@
+import { JSON } from "../..";
+import { serializeArray } from "./array";
+import { serializeBool } from "./bool";
+import { serializeInteger } from "./integer";
+import { serializeString } from "./string";
+
+export function serializeArbitrary(src: JSON.Value): void {
+  switch (src.type) {
+    case JSON.Types.U8:
+      serializeInteger<u8>(src.get<u8>());
+      break;
+    case JSON.Types.U16:
+      serializeInteger<u16>(src.get<u16>());
+      break;
+    case JSON.Types.U32:
+      serializeInteger<u32>(src.get<u32>());
+      break;
+    case JSON.Types.U64:
+      serializeInteger<u64>(src.get<u64>());
+      break;
+    case JSON.Types.String:
+      serializeString(src.get<string>());
+      break;
+    case JSON.Types.Bool:
+      serializeBool(src.get<bool>());
+    case JSON.Types.Array: {
+      serializeArray(src.get<JSON.Value[]>());
+      break;
+    }
+    default: {
+      const fn = JSON.Value.METHODS.get(src.type - JSON.Types.Struct);
+      const value = src.get<usize>();
+      call_indirect<string>(fn, 0, value);
+    }
+  }
+}

package/assembly/serialize/simple/array.ts

@@ -0,0 +1,32 @@
+import { bs } from "../../../modules/bs";
+import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
+import { JSON } from "../..";
+
+export function serializeArray<T extends any[]>(src: T): void {
+  const end = src.length - 1;
+  let i = 0;
+  if (end == -1) {
+    bs.ensureSize(4);
+    store<u32>(bs.offset, 6094939);
+    bs.offset += 4;
+    return;
+  }
+  bs.ensureSize(end << 3);
+
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+
+  while (i < end) {
+    const block = unchecked(src[i++]);
+    JSON.__serialize<valueof<T>>(block);
+    bs.ensureSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+
+  const lastBlock = unchecked(src[end]);
+  JSON.__serialize<valueof<T>>(lastBlock);
+  bs.ensureSize(2);
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/simple/bool.ts

@@ -0,0 +1,19 @@
+import { bs } from "../../../modules/bs";
+
+/**
+ * Serialize a bool to type string
+ * @param data data to serialize
+ * @returns void
+ */
+export function serializeBool(data: bool): void {
+  if (data == true) {
+    bs.ensureSize(8);
+    store<u64>(bs.offset, 28429475166421108);
+    bs.offset += 8;
+  } else {
+    bs.ensureSize(10);
+    store<u64>(bs.offset, 32370086184550502);
+    store<u64>(bs.offset, 101, 8);
+    bs.offset += 10;
+  }
+}

package/assembly/serialize/simple/date.ts

@@ -0,0 +1,13 @@
+import { bs } from "../../../modules/bs";
+import { QUOTE } from "../../custom/chars";
+import { bytes } from "../../util/bytes";
+
+export function serializeDate(src: Date): void {
+  const data = src.toISOString();
+  const dataSize = bytes(data);
+  bs.ensureSize(dataSize + 4);
+  store<u16>(bs.offset, QUOTE);
+  memory.copy(bs.offset + 2, changetype<usize>(data), dataSize);
+  store<u16>(bs.offset + dataSize, QUOTE, 2);
+  bs.offset += dataSize + 4;
+}

package/assembly/serialize/simple/float.ts

@@ -0,0 +1,7 @@
+import { dtoa_buffered } from "util/number";
+import { bs } from "../../../modules/bs";
+
+export function serializeFloat<T extends number>(data: T): void {
+  bs.ensureSize(64);
+  bs.offset += dtoa_buffered(bs.offset, data) << 1;
+}

package/assembly/serialize/simple/integer.ts

@@ -0,0 +1,7 @@
+import { itoa_buffered } from "util/number";
+import { bs } from "../../../modules/bs";
+
+export function serializeInteger<T extends number>(data: T): void {
+  bs.ensureSize(sizeof<T>() << 3);
+  bs.offset += itoa_buffered(bs.offset, data) << 1;
+}

package/assembly/serialize/simple/map.ts

@@ -0,0 +1,43 @@
+import { JSON } from "../..";
+import { BRACE_LEFT, BRACE_RIGHT, COLON, COMMA } from "../../custom/chars";
+import { bs } from "../../../modules/bs";
+
+export function serializeMap<T extends Map<any, any>>(src: T): void {
+  const srcSize = src.size;
+  const srcEnd = srcSize - 1;
+
+  if (srcSize == 0) {
+    bs.ensureSize(4);
+    store<u32>(bs.offset, 8192123);
+    bs.offset += 4;
+    return;
+  }
+
+  let keys = src.keys();
+  let values = src.values();
+
+  bs.ensureSize(srcSize << 3); // This needs to be predicted better
+
+  store<u16>(bs.offset, BRACE_LEFT);
+  bs.offset += 2;
+
+  for (let i = 0; i < srcEnd; i++) {
+    JSON.__serialize(unchecked(keys[i]));
+    bs.ensureSize(2);
+    store<u16>(bs.offset, COLON);
+    bs.offset += 2;
+    JSON.__serialize(unchecked(values[i]));
+    bs.ensureSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+
+  JSON.__serialize(unchecked(keys[srcEnd]));
+  bs.ensureSize(2);
+  store<u16>(bs.offset, COLON);
+  bs.offset += 2;
+  JSON.__serialize(unchecked(values[srcEnd]));
+  bs.ensureSize(2);
+  store<u16>(bs.offset, BRACE_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/simple/object.ts

@@ -0,0 +1,7 @@
+interface GeneratedInterface {
+  __SERIALIZE(ptr: usize): string;
+}
+
+export function serializeObject<T extends GeneratedInterface>(data: T): void {
+  changetype<nonnull<T>>(data).__SERIALIZE(changetype<usize>(data));
+}

package/assembly/serialize/simple/string.ts

@@ -0,0 +1,48 @@
+import { _intTo16 } from "../../custom/util";
+import { bytes } from "../../util/bytes";
+import { bs } from "../../../modules/bs";
+import { BACK_SLASH, QUOTE } from "../../custom/chars";
+import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
+
+/**
+ * Serializes valid strings into their JSON counterpart
+ * @param src string
+ * @returns void
+ */
+export function serializeString(src: string): void {
+  const srcSize = bytes(src);
+  bs.ensureSize(srcSize + 4);
+  let srcPtr = changetype<usize>(src);
+  const srcEnd = srcPtr + srcSize;
+
+  store<u16>(bs.offset, QUOTE);
+  bs.offset += 2;
+
+  let lastPtr: i32 = srcPtr;
+  while (srcPtr < srcEnd) {
+    const code = load<u16>(srcPtr);
+    if (code == 34 || code == 92 || code < 32) {
+      const remBytes = srcPtr - lastPtr;
+      memory.copy(bs.offset, lastPtr, remBytes);
+      bs.offset += remBytes;
+      const escaped = load<u32>(SERIALIZE_ESCAPE_TABLE + (code << 2));
+      if ((escaped & 0xffff) != BACK_SLASH) {
+        bs.ensureSize(10);
+        store<u64>(bs.offset, 13511005048209500, 0);
+        store<u32>(bs.offset, escaped, 8);
+        bs.offset += 12;
+      } else {
+        bs.ensureSize(2);
+        store<u32>(bs.offset, escaped, 0);
+        bs.offset += 4;
+      }
+      lastPtr = srcPtr + 2;
+    }
+    srcPtr += 2;
+  }
+  const remBytes = srcEnd - lastPtr;
+  memory.copy(bs.offset, lastPtr, remBytes);
+  bs.offset += remBytes;
+  store<u16>(bs.offset, QUOTE);
+  bs.offset += 2;
+}

package/assembly/test.ts

@@ -1,35 +1,49 @@
 import { JSON } from ".";
+// @json or @serializable work here
+@json
+class Vec3 {
+  x: f64 = 0.0;
+  y: f64 = 0.0;
+  z: f64 = 0.0;
+}
 
 
 @json
-class Vec3 {
-  public x: i32 = 0;
-  public y: i32 = 0;
-  public z: i32 = 0;
+class Player {
+  // @alias("first name")
+  firstName!: string;
+  lastName!: string;
+  lastActive!: i32[];
+  // Drop in a code block, function, or expression that evaluates to a boolean
+  @omitif((self: Player): boolean => self.age < 18)
+  age!: i32;
+  // @omitnull()
+  pos!: Vec3 | null;
+  isVerified!: boolean;
+  @inline __INITIALIZE(): this {
+    this.firstName = "";
+    this.lastName = "";
+    this.pos = changetype<nonnull<Vec3 | null>>(__new(offsetof<nonnull<Vec3 | null>>(), idof<nonnull<Vec3 | null>>())).__INITIALIZE();
+    return this;
+  }
 }
 
-// @json
-// class Base {
-//   public bam: string = "harekogkeorgke"
-// }
+const player: Player = {
+  firstName: "Jairus",
+  lastName: "Tanaka",
+  lastActive: [1, 20, 2025],
+  age: 18,
+  pos: {
+    x: 3.4,
+    y: 1.2,
+    z: 8.3,
+  },
+  isVerified: true,
+};
 
-// @json
-// class Foo extends Base {
-//   public bar: JSON.Raw = "\"this is ok\'"
-//   public baz: i32 = 0;
-//   public pos: Vec3<Vec3<i32>> = {
-//     x: 1,
-//     y: 2,
-//     z: {
-//       x: 1,
-//       y: 2,
-//       z: 3
-//     }
-//   }
-//   // ^ this is not okay
-// }
+const stringified = JSON.stringify<Player>(player);
+console.log("Serialized: " + stringified);
+const parsed = JSON.parse<Player>(stringified);
+console.log("Deserialized: " + JSON.stringify<Player>(parsed));
 
-const serialized = JSON.stringify(new Vec3());
-console.log("Serialized: " + serialized);
-const deserialized = JSON.parseSafe<Vec3>(`{"x":1,"y":true,"z":3}`);
-console.log("Deserialized: " + JSON.stringify(deserialized));
+console.log("Deserialized: " + JSON.stringify(JSON.parse<i32[]>("[1,2,3]")))

package/assembly/tsconfig.json

@@ -2,96 +2,7 @@
   "extends": "assemblyscript/std/assembly.json",
   "include": ["./**/*.ts"],
   "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-    /* Projects */
-    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
-    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
-    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
-    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-    /* Language and Environment */
-    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
-    "experimentalDecorators": true /* Enable experimental support for TC39 stage 2 draft decorators. */,
-    "emitDecoratorMetadata": true /* Emit design-type metadata for decorated declarations in source files. */,
-    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
-    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
-    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-    /* Modules */
-    "module": "commonjs" /* Specify what module code is generated. */,
-    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
-    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-    /* JavaScript Support */
-    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
-    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-    /* Emit */
-    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
-    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
-    // "removeComments": true,                           /* Disable emitting comments. */
-    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
-    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
-    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
-    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
-    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
-    /* Interop Constraints */
-    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
-    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
-    /* Type Checking */
-    "strict": false /* Enable all strict type-checking options. */,
-    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
-    "strictNullChecks": true /* When type checking, take into account 'null' and 'undefined'. */,
-    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
-    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
-    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
-    // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */
-    "noUnusedLocals": true /* Enable error reporting when local variables aren't read. */,
-    "noUnusedParameters": true /* Raise an error when a function parameter isn't read. */,
-    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
-    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
-    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-    /* Completeness */
-    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
   }
 }

package/assembly/util/atoi.ts

@@ -0,0 +1,35 @@
+/**
+ * ATOI optimized for non-exponential integers
+ * @param str
+ * @returns
+ */
+// @ts-ignore: Decorator valid here
+@inline export function atoi<T>(srcStart: usize, srcEnd: usize): T {
+  // @ts-ignore: type
+  let val: T = 0;
+  if (isSigned<T>()) {
+    if (load<u16>(srcStart) == 45) {
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        // @ts-ignore: type
+        val = (val * 10 + (load<u16>(srcStart) - 48)) as T;
+        srcStart += 2;
+      }
+      return -val as T;
+    } else {
+      while (srcStart < srcEnd) {
+        // @ts-ignore: type
+        val = (val * 10 + (load<u16>(srcStart) - 48)) as T;
+        srcStart += 2;
+      }
+      return val as T;
+    }
+  } else {
+    while (srcStart < srcEnd) {
+      // @ts-ignore: type
+      val = (val * 10 + (load<u16>(srcStart) - 48)) as T;
+      srcStart += 2;
+    }
+    return val as T;
+  }
+}

package/assembly/util/bytes.ts

@@ -0,0 +1,12 @@
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+
+// @ts-ignore: Decorator valid here
+@inline export function bytes<T>(o: T): i32 {
+  if (isInteger<T>() || isFloat<T>()) {
+    return sizeof<T>();
+  } else if (isManaged<T>() || isReference<T>()) {
+    return changetype<OBJECT>(changetype<usize>(o) - TOTAL_OVERHEAD).rtSize;
+  } else {
+    ERROR("Cannot convert type " + nameof<T>() + " to bytes!");
+  }
+}

package/assembly/util/concat.ts

@@ -0,0 +1,9 @@
+import { bytes } from "./bytes";
+export function concat(left: string, right: string): string {
+  const leftSize: usize = bytes(left);
+  const rightSize: usize = bytes(right);
+  const jointSize: usize = leftSize + rightSize;
+  const jointPtr = __renew(changetype<usize>(left), jointSize);
+  memory.copy(changetype<usize>(left) + leftSize, changetype<usize>(right), rightSize);
+  return changetype<string>(jointPtr);
+}

package/assembly/util/getArrayDepth.ts

@@ -0,0 +1,17 @@
+/**
+ * A terrible function which ascertains the depth of a certain array
+ * Depending on the optimization level, this can be essentially nop
+ * @returns depth of array
+ */
+
+// @ts-ignore: Decorator
+export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
+  if (!isArray<T>()) {
+    return 0;
+  } else if (isArray<valueof<T>>()) {
+    depth++;
+    return getArrayDepth<valueof<T>>(depth);
+  } else {
+    return depth;
+  }
+}

package/assembly/util/index.ts

@@ -0,0 +1,5 @@
+export * from "./isSpace";
+export * from "./atoi";
+export * from "./concat";
+export * from "./bytes";
+export * from "./nextPowerOf2";

package/assembly/util/isSpace.ts

@@ -0,0 +1,4 @@
+// @ts-ignore
+@inline export function isSpace(code: u16): boolean {
+  return code == 0x20 || code - 9 <= 4;
+}

package/assembly/util/nextPowerOf2.ts

@@ -0,0 +1,4 @@
+// @ts-ignore: Decorator valid here
+@inline export function nextPowerOf2(n: u32): u32 {
+  return 1 << (32 - clz(n - 1));
+}

package/assembly/util/ptrToStr.ts

@@ -0,0 +1,7 @@
+// @ts-ignore: decorator
+@inline export function ptrToStr(start: usize, end: usize): string {
+  const size = end - start;
+  const out = __new(size, idof<string>());
+  memory.copy(out, start, size);
+  return changetype<string>(out);
+}

package/assembly/util/snp.ts

@@ -0,0 +1,69 @@
+// e -> 101
+// E -> 69
+// - -> 45
+// . -> 46
+
+import { POW_TEN_TABLE_32, POW_TEN_TABLE_64 } from "../globals/tables";
+import { atoi } from "./atoi";
+
+// @ts-ignore: Decorator valid here
+@inline function snp<T extends number>(srcStart: usize, srcEnd: usize): T {
+  // @ts-ignore: type
+  let val: T = 0;
+  let char = load<u16>(srcStart) - 48;
+  if (isFloat<T>()) {
+    while (srcStart < srcEnd) {}
+  } else if (isInteger<T>()) {
+    if (isSigned<T>() && char == 65533) {
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        char = load<u16>(srcStart) - 48;
+        if (char < 10) {
+          // @ts-ignore: type
+          val = (val * 10 + char) as T;
+        } else if (char == 101 || char == 69) {
+          srcStart += 2;
+          char = load<u16>(srcStart);
+          if (char == 45) {
+            // @ts-ignore: type
+            return -(val / pow10(atoi(srcStart + 2, srcEnd)));
+          } else {
+            // @ts-ignore: type
+            return -(val * pow10(atoi(srcStart, srcEnd)));
+          }
+        }
+        srcStart += 2;
+      }
+      return -val as T;
+    } else {
+      while (srcStart < srcEnd) {
+        char = load<u16>(srcStart) - 48; // this operation is repeated twice
+        if (char < 10) {
+          // @ts-ignore: type
+          val = (val * 10 + char) as T;
+        } else if (char == 101 || char == 69) {
+          srcStart += 2;
+          char = load<u16>(srcStart);
+          if (char == 45) {
+            // @ts-ignore: type
+            return val / pow10(atoi(srcStart + 2, srcEnd));
+          } else {
+            // @ts-ignore: type
+            return val * pow10(atoi(srcStart, srcEnd));
+          }
+        }
+        srcStart += 2;
+      }
+      return val as T;
+    }
+  }
+}
+
+// @ts-ignore: Decorator valid here
+@inline function pow10<T extends number>(x: u16): T {
+  if (sizeof<T>() == 8) {
+    return <T>load<u64>(POW_TEN_TABLE_64 + x);
+  } else {
+    return <T>load<u32>(POW_TEN_TABLE_32 + x);
+  }
+}

package/bench.js

@@ -34,9 +34,9 @@ const vec = {
 let data;
 
 const bench = new Bench({ time: 1000 })
-  /*.add("stringify float", () => {
-        data = JSON.stringify(1.2345)
-    })
+  .add("stringify float", () => {
+    data = JSON.stringify('h\\ello wor"ld');
+  }) /*
     .add("parse float", () => {
         data = JSON.parse("1.2345")
     })
@@ -65,10 +65,10 @@ const bench = new Bench({ time: 1000 })
     .add("Stringify String", () => {
         data = JSON.stringify('Hello "World!');
     })
-*/
+
   .add("Parse String", () => {
     data = JSON.stringify('hello "world abc');
-  })
+  })*/
   .todo("unimplemented .add");
 
 await bench.run();