json-as 1.2.6 → 1.3.0

package/assembly/serialize/index/arbitrary.ts

@@ -0,0 +1,70 @@
+import { JSON } from "../..";
+import { bs } from "../../../lib/as-bs";
+import { serializeArray } from "./array";
+import { serializeBool } from "./bool";
+import { serializeFloat } from "./float";
+import { serializeInteger } from "./integer";
+import { serializeMap } from "./map";
+import { serializeObject } from "./object";
+import { serializeString } from "./string";
+
+export function serializeArbitrary(src: JSON.Value): void {
+  switch (src.type) {
+    case JSON.Types.Null:
+      bs.proposeSize(8);
+      store<u64>(bs.offset, 30399761348886638);
+      bs.offset += 8;
+      break;
+    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.I8:
+      serializeInteger<i8>(src.get<i8>());
+      break;
+    case JSON.Types.I16:
+      serializeInteger<i16>(src.get<i16>());
+      break;
+    case JSON.Types.I32:
+      serializeInteger<i32>(src.get<i32>());
+      break;
+    case JSON.Types.I64:
+      serializeInteger<i64>(src.get<i64>());
+      break;
+    case JSON.Types.F32:
+      serializeFloat<f32>(src.get<f32>());
+      break;
+    case JSON.Types.F64:
+      serializeFloat<f64>(src.get<f64>());
+      break;
+    case JSON.Types.String:
+      serializeString(src.get<string>());
+      break;
+    case JSON.Types.Bool:
+      serializeBool(src.get<bool>());
+      break;
+    case JSON.Types.Array:
+      serializeArray(src.get<JSON.Value[]>());
+      break;
+    case JSON.Types.Object:
+      serializeObject(src.get<JSON.Obj>());
+      break;
+    case JSON.Types.Map:
+      serializeMap(src.get<Map<string, JSON.Value>>());
+      break;
+    default: {
+      const fn = JSON.Value.METHODS.get(src.type - JSON.Types.Struct);
+      const ptr = src.get<usize>();
+      call_indirect<void>(fn, 0, ptr);
+      break;
+    }
+  }
+}

package/assembly/serialize/index/array.ts

@@ -0,0 +1 @@
+export { serializeArray } from "../simple/array";

package/assembly/serialize/index/bool.ts

@@ -0,0 +1 @@
+export { serializeBool } from "../simple/bool";

package/assembly/serialize/index/date.ts

@@ -0,0 +1 @@
+export { serializeDate } from "../simple/date";

package/assembly/serialize/index/float.ts

@@ -0,0 +1 @@
+export { serializeFloat } from "../simple/float";

package/assembly/serialize/index/integer.ts

@@ -0,0 +1 @@
+export { serializeInteger } from "../simple/integer";

package/assembly/serialize/index/map.ts

@@ -0,0 +1 @@
+export { serializeMap } from "../simple/map";

package/assembly/serialize/index/object.ts

@@ -0,0 +1,46 @@
+import { bs } from "../../../lib/as-bs";
+import { JSON } from "../..";
+import { BRACE_LEFT, BRACE_RIGHT, COLON, COMMA } from "../../custom/chars";
+import { serializeArbitrary } from "./arbitrary";
+import { serializeString } from "./string";
+
+export function serializeObject(src: JSON.Obj): void {
+  const srcSize = src.size;
+  const srcEnd = srcSize - 1;
+
+  if (srcSize == 0) {
+    bs.proposeSize(4);
+    store<u32>(bs.offset, 8192123);
+    bs.offset += 4;
+    return;
+  }
+
+  const keys = src.keys();
+  const values = src.values();
+
+  bs.growSize(2);
+  store<u16>(bs.offset, BRACE_LEFT);
+  bs.offset += 2;
+
+  for (let i = 0; i < srcEnd; i++) {
+    serializeString(unchecked(keys[i]));
+    bs.growSize(2);
+    store<u16>(bs.offset, COLON);
+    bs.offset += 2;
+
+    serializeArbitrary(unchecked(values[i]));
+    bs.growSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+
+  serializeString(unchecked(keys[srcEnd]));
+  bs.growSize(2);
+  store<u16>(bs.offset, COLON);
+  bs.offset += 2;
+  serializeArbitrary(unchecked(values[srcEnd]));
+
+  bs.growSize(2);
+  store<u16>(bs.offset, BRACE_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/index/raw.ts

@@ -0,0 +1 @@
+export { serializeRaw } from "../simple/raw";

package/assembly/serialize/index/set.ts

@@ -0,0 +1 @@
+export { serializeSet } from "../simple/set";

package/assembly/serialize/index/staticarray.ts

@@ -0,0 +1 @@
+export { serializeStaticArray } from "../simple/staticarray";

package/assembly/serialize/index/string.ts

@@ -0,0 +1,15 @@
+import { JSONMode } from "../..";
+import { serializeString as serializeString_NAIVE } from "../simple/string";
+import { serializeString_SIMD } from "../simd/string";
+import { serializeString_SWAR } from "../swar/string";
+
+
+@inline export function serializeString(src: string): void {
+  if (JSON_MODE == JSONMode.SIMD) {
+    serializeString_SIMD(src);
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    serializeString_NAIVE(src);
+  } else {
+    serializeString_SWAR(src);
+  }
+}

package/assembly/serialize/index/struct.ts

@@ -0,0 +1 @@
+export { serializeStruct } from "../simple/struct";

package/assembly/serialize/index/typedarray.ts

@@ -0,0 +1 @@
+export { serializeArrayBufferUnsafe, serializeTypedArray } from "../simple/typedarray";

package/assembly/serialize/index.ts

@@ -0,0 +1,13 @@
+export * from "./index/arbitrary";
+export * from "./index/array";
+export * from "./index/bool";
+export * from "./index/date";
+export * from "./index/float";
+export * from "./index/integer";
+export * from "./index/map";
+export * from "./index/object";
+export * from "./index/raw";
+export * from "./index/set";
+export * from "./index/staticarray";
+export * from "./index/string";
+export * from "./index/struct";

package/assembly/serialize/simd/string.ts

@@ -174,8 +174,7 @@ export function serializeString_SIMD(src: string): void {
   store<u16>(bs.offset, 34); // "
   bs.offset += 2;
 
-  if (isDefined(JSON_CACHE))
-    sc.insertCached(changetype<usize>(src), srcStart, srcSize);
+  if (isDefined(JSON_CACHE)) sc.insertCached(changetype<usize>(src), srcStart, srcSize);
 }
 
 // @ts-expect-error: @inline is a valid decorator

package/assembly/serialize/simple/raw.ts

@@ -11,10 +11,6 @@ import { bytes } from "../../util";
 @inline export function serializeRaw(data: JSON.Raw): void {
   const dataSize = bytes(data.data);
   bs.proposeSize(dataSize);
-  memory.copy(
-    changetype<usize>(bs.offset),
-    changetype<usize>(data.data),
-    dataSize,
-  );
+  memory.copy(changetype<usize>(bs.offset), changetype<usize>(data.data), dataSize);
   bs.offset += dataSize;
 }

package/assembly/serialize/simple/typedarray.ts

@@ -0,0 +1,63 @@
+import { bs } from "../../../lib/as-bs";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../custom/chars";
+import { serializeFloat } from "./float";
+import { serializeInteger } from "./integer";
+
+
+@inline
+function serializeTypedArrayElement<T extends ArrayLike<number>>(src: T, index: i32): void {
+  if (isFloat<valueof<T>>()) {
+    serializeFloat<valueof<T>>(unchecked(src[index]));
+  } else {
+    serializeInteger<valueof<T>>(unchecked(src[index]));
+  }
+}
+
+export function serializeTypedArray<T extends ArrayLike<number>>(src: T): void {
+  bs.proposeSize(4);
+  const end = src.length - 1;
+  if (end == -1) {
+    store<u32>(bs.offset, 6094939);
+    bs.offset += 4;
+    return;
+  }
+
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+
+  for (let i = 0; i < end; i++) {
+    serializeTypedArrayElement(src, i);
+    bs.growSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+
+  serializeTypedArrayElement(src, end);
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}
+
+export function serializeArrayBufferUnsafe(srcStart: usize, byteLength: i32): void {
+  const end = byteLength - 1;
+
+  bs.proposeSize(4);
+  if (end == -1) {
+    store<u32>(bs.offset, 6094939);
+    bs.offset += 4;
+    return;
+  }
+
+  store<u16>(bs.offset, BRACKET_LEFT);
+  bs.offset += 2;
+
+  for (let i = 0; i < end; i++) {
+    serializeInteger<u8>(load<u8>(srcStart + <usize>i));
+    bs.growSize(2);
+    store<u16>(bs.offset, COMMA);
+    bs.offset += 2;
+  }
+
+  serializeInteger<u8>(load<u8>(srcStart + <usize>end));
+  store<u16>(bs.offset, BRACKET_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/swar/string.ts

@@ -145,8 +145,7 @@ export function serializeString_SWAR(src: string): void {
   store<u16>(bs.offset, 34); // "
   bs.offset += 2;
 
-  if (isDefined(JSON_CACHE))
-    sc.insertCached(changetype<usize>(src), srcStart, srcSize);
+  if (isDefined(JSON_CACHE)) sc.insertCached(changetype<usize>(src), srcStart, srcSize);
 }
 
 // @ts-expect-error: @inline is a valid decorator
@@ -169,14 +168,8 @@ export function serializeString_SWAR(src: string): void {
 // @ts-expect-error: @inline is a valid decorator
 @inline export function detect_escapable_u64_swar_safe(block: u64): u64 {
   const lo = block & 0x00ff_00ff_00ff_00ff;
-  const ascii_mask =
-    ((lo - 0x0020_0020_0020_0020) |
-      ((lo ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) |
-      ((lo ^ 0x005c_005c_005c_005c) - 0x0001_0001_0001_0001)) &
-    (0x0080_0080_0080_0080 & ~lo);
-  const hi_mask =
-    ((block - 0x0100_0100_0100_0100) & ~block & 0x8000_8000_8000_8000) ^
-    0x8000_8000_8000_8000;
+  const ascii_mask = ((lo - 0x0020_0020_0020_0020) | ((lo ^ 0x0022_0022_0022_0022) - 0x0001_0001_0001_0001) | ((lo ^ 0x005c_005c_005c_005c) - 0x0001_0001_0001_0001)) & (0x0080_0080_0080_0080 & ~lo);
+  const hi_mask = ((block - 0x0100_0100_0100_0100) & ~block & 0x8000_8000_8000_8000) ^ 0x8000_8000_8000_8000;
   return (ascii_mask & (~hi_mask >> 8)) | hi_mask;
 }
 

package/assembly/test.ts

@@ -1,30 +1,24 @@
-class Test {
-  a: string;
-  b: string;
+function get_mask_chars(src: string, mask: u64): void {
+  const srcPtr = changetype<usize>(src);
+  while (mask != 0) {
+    const laneIdx = usize(ctz(mask) >> 3);
+    mask &= ~(0xffff << (laneIdx << 3));
+    // mask &= mask - 1;
+    console.log("Lane:  " + laneIdx.toString());
+    const srcIdx = srcPtr + laneIdx;
+    const chunk = load<u32>(srcIdx);
+    const code = <u16>(chunk >> 16);
+
+    console.log("Chunk: " + String.fromCharCode(chunk & 0xffff) + String.fromCharCode(chunk >> 16));
+    console.log("Code:  " + String.fromCharCode(load<u16>(srcIdx)));
+  }
 }
 
-// @ts-expect-error: decorator
-@inline function deserializeTest_NAIVE(
-  srcStart: usize,
-  srcEnd: usize,
-  dst: Test,
-): usize {
-  // fast path
-  do {
-    if (
-      load<u64>(srcStart) != load<u64>(changetype<usize>('{"a"')) ||
-      load<u16>(srcStart, 8) != 0x3a
-    )
-      break;
-    srcStart += 10;
-    srcStart += deserializeString_NAIVE(srcStart, srcEnd); // this needs to somehow return an error (perhaps usize.MAX_VALUE) and also deserialize to the a field in dst.
-    if (
-      load<u64>(srcStart) != load<u64>(changetype<usize>(',"b"')) ||
-      load<u16>(srcStart, 8) != 0x3a
-    )
-      break;
-    srcStart += 10;
-    srcStart += deserializeString_NAIVE(srcStart, srcEnd);
-  } while (false);
-  // have slow path here
+function backslash_or_quote_mask(block: u64): u64 {
+  const b = block ^ 0x005c_005c_005c_005c;
+  const q = block ^ 0x0022_0022_0022_0022;
+  return (((q - 0x0001_0001_0001_0001) & ~q) | ((b - 0x0001_0001_0001_0001) & ~b)) & 0x0080_0080_0080_0080;
 }
+
+const input = '\\"a"';
+get_mask_chars(input, backslash_or_quote_mask(load<u64>(changetype<usize>(input))));

package/assembly/util/concat.ts

@@ -4,10 +4,6 @@ export function concat(left: string, right: string): string {
   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,
-  );
+  memory.copy(changetype<usize>(left) + leftSize, changetype<usize>(right), rightSize);
   return changetype<string>(jointPtr);
 }

package/assembly/util/index.ts

@@ -3,3 +3,4 @@ export * from "./atoi";
 export * from "./concat";
 export * from "./bytes";
 export * from "./nextPowerOf2";
+export * from "./stringScan";

package/assembly/util/masks.ts

@@ -11,27 +11,21 @@ export function mask_to_string(mask: u64): string {
   return result;
 }
 
+export function block_to_string(block: u64): string {
+  let result = "     ";
+  const buf = changetype<usize>(new ArrayBuffer(8));
+  store<u64>(buf, block);
+  result += String.fromCharCode(load<u16>(buf, 6)) + "     ";
+  result += String.fromCharCode(load<u16>(buf, 4)) + "     ";
+  result += String.fromCharCode(load<u16>(buf, 2)) + "     ";
+  result += String.fromCharCode(load<u16>(buf, 0)) + "     ";
+  return result;
+}
+
 export function mask_to_string_v128(vec: v128): string {
   let result = "0x";
 
-  const lanes: i8[] = [
-    i8x16.extract_lane_s(vec, 0),
-    i8x16.extract_lane_s(vec, 1),
-    i8x16.extract_lane_s(vec, 2),
-    i8x16.extract_lane_s(vec, 3),
-    i8x16.extract_lane_s(vec, 4),
-    i8x16.extract_lane_s(vec, 5),
-    i8x16.extract_lane_s(vec, 6),
-    i8x16.extract_lane_s(vec, 7),
-    i8x16.extract_lane_s(vec, 8),
-    i8x16.extract_lane_s(vec, 9),
-    i8x16.extract_lane_s(vec, 10),
-    i8x16.extract_lane_s(vec, 11),
-    i8x16.extract_lane_s(vec, 12),
-    i8x16.extract_lane_s(vec, 13),
-    i8x16.extract_lane_s(vec, 14),
-    i8x16.extract_lane_s(vec, 15),
-  ];
+  const lanes: i8[] = [i8x16.extract_lane_s(vec, 0), i8x16.extract_lane_s(vec, 1), i8x16.extract_lane_s(vec, 2), i8x16.extract_lane_s(vec, 3), i8x16.extract_lane_s(vec, 4), i8x16.extract_lane_s(vec, 5), i8x16.extract_lane_s(vec, 6), i8x16.extract_lane_s(vec, 7), i8x16.extract_lane_s(vec, 8), i8x16.extract_lane_s(vec, 9), i8x16.extract_lane_s(vec, 10), i8x16.extract_lane_s(vec, 11), i8x16.extract_lane_s(vec, 12), i8x16.extract_lane_s(vec, 13), i8x16.extract_lane_s(vec, 14), i8x16.extract_lane_s(vec, 15)];
 
   for (let i = 15; i >= 0; i--) {
     const byte = lanes[i];

package/assembly/util/snp.ts

@@ -7,10 +7,7 @@ import { POW_TEN_TABLE_32, POW_TEN_TABLE_64 } from "../globals/tables";
 import { atoi } from "./atoi";
 
 // @ts-ignore: Decorator valid here
-@inline export function snp<T extends number>(
-  srcStart: usize,
-  srcEnd: usize,
-): T {
+@inline export function snp<T extends number>(srcStart: usize, srcEnd: usize): T {
   // @ts-ignore: type
   let val: T = 0;
   let char = load<u16>(srcStart) - 48;

package/assembly/util/stringScan.ts

@@ -0,0 +1,24 @@
+import { BACK_SLASH, QUOTE } from "../custom/chars";
+
+// @ts-ignore
+@inline export function isUnescapedQuote(ptr: usize): bool {
+  if (load<u16>(ptr) != QUOTE) return false;
+
+  let escaped = false;
+  while (ptr >= 2 && load<u16>(ptr - 2) == BACK_SLASH) {
+    escaped = !escaped;
+    ptr -= 2;
+  }
+
+  return !escaped;
+}
+
+// @ts-ignore
+@inline export function scanStringEnd(ptr: usize, end: usize): usize {
+  ptr += 2;
+  while (ptr < end) {
+    if (load<u16>(ptr) == QUOTE && isUnescapedQuote(ptr)) return ptr;
+    ptr += 2;
+  }
+  return end;
+}

package/assembly/util/swar.ts

@@ -3,10 +3,5 @@
   // (c & 0xF) + 9 * (c >> 6)
   block = (block & 0x0f000f000f000f) + ((block >> 6) & 0x03000300030003) * 9;
 
-  return <u16>(
-    (((block >> 0) << 12) |
-      ((block >> 16) << 8) |
-      ((block >> 32) << 4) |
-      (block >> 48))
-  );
+  return <u16>(((block >> 0) << 12) | ((block >> 16) << 8) | ((block >> 32) << 4) | (block >> 48));
 }

package/eslint.config.js

@@ -2,21 +2,15 @@
 
 import eslint from "@eslint/js";
 import tseslint from "typescript-eslint";
+import aseslint from "./tools/assemblyscript-eslint-local.js";
 
 export default tseslint.config(
   {
-    ignores: [
-      "bin/**",
-      "templates/**",
-      "tests/**/*.js",
-      "transform/lib/**",
-      "build/**",
-      "assembly/**/*.ts",
-      "lib/as-bs.ts",
-    ],
+    ignores: ["bin/**", "templates/**", "tests/**/*.js", "transform/lib/**", "build/**", ".as-test/**", "assembly/**/*.tmp.ts"],
   },
   eslint.configs.recommended,
   ...tseslint.configs.recommended,
+  aseslint.config,
   {
     files: ["**/*.{js,mjs,cjs,ts}"],
     languageOptions: {
@@ -31,10 +25,24 @@ export default tseslint.config(
   {
     files: ["**/*.ts"],
     rules: {
-      "@typescript-eslint/no-unused-vars": [
-        "error",
-        { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
-      ],
+      "@typescript-eslint/no-namespace": "off",
+      "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_", varsIgnorePattern: "^_" }],
+    },
+  },
+  {
+    files: ["assembly/**/*.ts", "lib/**/*.ts"],
+    rules: {
+      "@typescript-eslint/ban-ts-comment": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unsafe-function-type": "off",
+      "@typescript-eslint/no-unused-vars": "off",
+      "@typescript-eslint/triple-slash-reference": "off",
+      "no-constant-condition": "off",
+      "no-empty": "off",
+      "no-dupe-else-if": "off",
+      "no-loss-of-precision": "off",
+      "no-useless-escape": "off",
+      "prefer-const": "off",
     },
   },
   {