json-as 0.1.9 → 0.2.3

package/README.md

@@ -18,15 +18,13 @@
 - ✅ Null
 - ✅ Dynamic Arrays
 - ✅ Dynamic Types
-- ❌ Dynamic Objects (Soon!)
+- ✅ Dynamic Objects
 - ✅ Whitespace
 
-## WARNING: Possible breaking changes coming for v2.0.0
-
 ## Usage
 
 ```js
-import { JSON, unknown } from 'json-as'
+import { JSON } from 'json-as'
 ```
 
 **Object**
@@ -51,7 +49,7 @@ const parsed = JSON.parse<JSONSchema>(stringified)
 // { firstName: "Jairus", lastName: "Tanaka", age: 14 }
 ```
 
-**Array (Typed)**
+**Array**
 
 ```js
 const stringified = JSON.stringify(['Hello', 'World'])
@@ -61,16 +59,6 @@ const parsed = JSON.parse<JSONSchema>(stringified)
 // ["Hello", "World"]
 ```
 
-**Array (Dynamic)**
-
-```js
-const stringified = JSON.stringify(["Welcome to dynamic arrays", 3.14, ["Deep"], true, "It also supports nulls", null])
-// '["Welcome to dynamic arrays",3.14,["Deep"],true,"It also supports nulls",null]'
-
-const parsed = JSON.parse<unknown[]>(stringified)
-// ["Welcome to dynamic arrays", 3.14, ["Deep"], true, "It also supports nulls", null]
-```
-
 **Float**
 
 ```js
@@ -120,34 +108,19 @@ const stringified = JSON.stringify(null)
 const parsed = JSON.parse(stringified)
 // null
 ```
-
-## Accessing unknown types
-**Breaking changes for v2.0.0!**
-**Experimental usage only**
-
-```js
-const parsed = JSON.parse<unknown[]>(["Welcome to dynamic arrays",3.14,["Deep"],true,"It also supports nulls",null])
-console.log(parsed[0].get<string>())
-// "Welcome to dynamic arrays"
-console.log(parsed[1].get<f64>().toString())
-// 3.14
-```
-
 ## Benchmarks
 
 ```
-AS-JSON Stringify String: ~1858051.4 ops/s | 53.82ms
-AS-JSON Parse String: ~4321632.43 ops/s | 23.14ms     
-AS-JSON Stringify Integer: ~8529956.89 ops/s | 11.72ms
-AS-JSON Parse Integer: ~27839325.77 ops/s | 3.59ms
-AS-JSON Stringify Float: ~5128590.39 ops/s | 19.5ms    
-AS-JSON Parse Float: ~21467505.24 ops/s | 4.66ms       
-AS-JSON Stringify Boolean: ~361837455.83 ops/s | 0.28ms
-AS-JSON Parse Boolean: ~51522012.58 ops/s | 1.94ms     
-AS-JSON Stringify Array: ~1421792.72 ops/s | 70.33ms
-AS-JSON Parse Array: ~3755593.05 ops/s | 26.63ms
-AS-JSON Stringify Object: ~3309471.1 ops/s | 30.22ms
-AS-JSON Parse Object: ~1054387.45 ops/s | 94.84ms
-AS-JSON Stringify Dynamic Array: ~285433.75 ops/s | 350.34ms
-AS-JSON Parse Dynamic Array: ~661516.87 ops/s | 151.17ms
+AS-JSON Stringify String: ~4191267.51 ops/s | 23.86ms
+AS-JSON Parse String: ~6218119.99 ops/s | 16.08ms
+AS-JSON Stringify Integer: ~13775012.61 ops/s | 7.26ms
+AS-JSON Parse Integer: ~55061164.13 ops/s | 1.82ms
+AS-JSON Stringify Float: ~7739399.89 ops/s | 12.92ms
+AS-JSON Parse Float: ~37522902.16 ops/s | 2.67ms
+AS-JSON Stringify Boolean: ~615015015.02 ops/s | 0.16ms
+AS-JSON Parse Boolean: ~93901879.87 ops/s | 1.06ms
+AS-JSON Stringify Array: ~2380329.74 ops/s | 42.01ms
+AS-JSON Parse Array: ~6258786.14 ops/s | 15.98ms
+AS-JSON Stringify Object: ~5245632.91 ops/s | 19.06ms
+AS-JSON Parse Object: ~1328576.06 ops/s | 75.27ms
 ```

package/assembly/DynamicObject.ts

@@ -0,0 +1,29 @@
+import { unknown } from "./unknown"
+
+/**
+ * Provides functionality common to all JavaScript objects.
+ */
+export class DynamicObject {
+    [key: string]: any
+    // Having it marked as 'any' is for intellisense only
+    protected __data: Map<string, unknown> = new Map<string, unknown>()
+    set(path: string, value: unknown): void {
+        this.__data.set(path, value)
+    }
+    get<T = unknown>(path: string): T {
+        let type!: T
+        if (type instanceof unknown) {
+            // @ts-ignore
+            return this.__data.get(path)
+        } else {
+            // @ts-ignore
+            return this.__data.get(path).get<T>()
+        }
+    }
+    static keys(o: DynamicObject): string[] {
+        return o.__data.keys()
+    }
+    static values(o: DynamicObject): unknown[] {
+        return o.__data.values()
+    }
+}

package/assembly/bench.ts

@@ -2,12 +2,12 @@ import 'wasi'
 
 import { Date } from 'as-wasi'
 
-import { JSON } from './json'
+import { JSON } from '.'
 
 import * as asJSON from "assemblyscript-json"
 
 import { unknown } from './unknown'
-import { Object } from './Object'
+import { DynamicObject } from './DynamicObject'
 
 // @ts-ignore
 @json
@@ -19,7 +19,7 @@ const jsonData: JSONSchema = {
     hello: 'world'
 }
 
-const o = new Object()
+const o = new DynamicObject()
 
 o['hello'] = unknown.wrap('world')
 
@@ -86,11 +86,11 @@ bench('AS-JSON Parse Object', () => {
 })
 
 bench('AS-JSON Stringify Dynamic Object', () => {
-    JSON.stringify<Object>(o)
+    JSON.stringify<DynamicObject>(o)
 })
 
 bench('AS-JSON Parse Object', () => {
-    JSON.parse<Object>('{"hello":"world"}')
+    JSON.parse<DynamicObject>('{"hello":"world"}')
 })
 
 bench('AS-JSON Stringify Dynamic Array', () => {
@@ -116,7 +116,7 @@ bench('AssemblyScript-JSON Stringify String', () => {
     String.UTF8.decode(binary.buffer)
     // Its odd. Not encoded in UTF16 Strings.
     // Since AS-JSON returns a string, so does assemblyscript-json in this bench.
-    // Or else, the bench is biased. 
+    // Or else, the bench is biased.
 })
 
 bench('AssemblyScript-JSON Parse String', () => {

package/assembly/{json.ts → index.ts}

@@ -1,8 +1,8 @@
 import { StringSink } from 'as-string-sink'
-import { Object } from './Object'
+import { DynamicObject } from './DynamicObject'
 import { unknown, unknownTypes } from './unknown'
 export { unknown, unknownTypes } from './unknown'
-export { Object } from './Object'
+export { DynamicObject as Object } from './DynamicObject'
 
 @global
 export class Nullable { }
@@ -29,7 +29,7 @@ const f_charCode: u16 = 116// "t"
 const nCode: u16 = 110// "n"
 const unknownId = idof<unknown>()
 const stringId = idof<string>()
-const objectId = idof<Object>()
+const objectId = idof<DynamicObject>()
 const arrayStringId = idof<string[]>()
 const arrayBooleanId = idof<boolean[]>()
 const arrayBoolId = idof<bool[]>()
@@ -81,7 +81,7 @@ export namespace JSON {
       return serializeArray<T>(data)
     } else if (data instanceof unknown) {
       return serializeUnknown(data)
-    } else if (data instanceof Object) {
+    } else if (data instanceof DynamicObject) {
       return serializeDynamicObject(data)
     }
 
@@ -115,16 +115,16 @@ export namespace JSON {
     // @ts-ignore
     else if (type instanceof unknown) return parseUnknown(data)
     // @ts-ignore
-    else if (type instanceof Object) return parseDynamicObject(data)
+    else if (type instanceof DynamicObject) return parseDynamicObject(data)
     // @ts-ignore
     return parseObject<T>(data)
   }
 }
 
-export function serializeDynamicObject(data: Object): string {
+export function serializeDynamicObject(data: DynamicObject): string {
   const result = new StringSink(lcbracket)
-  const keys = Object.keys(data)
-  const values = Object.values(data)
+  const keys = DynamicObject.keys(data)
+  const values = DynamicObject.values(data)
   const len: u32 = keys.length - 1
   if (len === -1) return '{}'
   for (let i: u32 = 0; i < len; i++) {
@@ -150,134 +150,134 @@ export function serializeUnknown(data: unknown): string {
     return serializeString(data.get<string>())
   }
   // @ts-ignore
-  else if (data.type === objectId) {
+  else if (data.type === unknownTypes.boolean) {
     // @ts-ignore
-    return serializeDynamicObject(data.get<Object>())
+    return serializeBoolean(data.get<boolean>())
   }
   // @ts-ignore
-  else if (data.type === arrayUnknownId) {
+  else if (data.type === unknownTypes.i8) {
     // @ts-ignore
-    return serializeUnknownArray(data.get<unknown[]>())
+    return data.get<i8>().toString()
   }
   // @ts-ignore
-  else if (data.type === arrayBoolId) {
+  else if (data.type === unknownTypes.i16) {
     // @ts-ignore
-    return serializeBooleanArray(data.get<bool[]>())
+    return data.get<i16>().toString()
   }
   // @ts-ignore
-  else if (data.type === arrayBooleanId) {
+  else if (data.type === unknownTypes.i32) {
     // @ts-ignore
-    return serializeBooleanArray(data.get<boolean[]>())
+    return data.get<i32>().toString()
   }
   // @ts-ignore
-  else if (data.type === arrayF32Id) {
+  else if (data.type === unknownTypes.i64) {
     // @ts-ignore
-    return serializeNumberArray<f32[]>(data.get<f32[]>())
+    return data.get<i64>().toString()
   }
   // @ts-ignore
-  else if (data.type === arrayF64Id) {
+  else if (data.type === unknownTypes.u8) {
     // @ts-ignore
-    return serializeNumberArray<f64[]>(data.get<f64[]>())
+    return data.get<u8>().toString()
   }
   // @ts-ignore
-  else if (data.type === arrayU8Id) {
+  else if (data.type === unknownTypes.u16) {
     // @ts-ignore
-    return serializeNumberArray<u8[]>(data.get<u8[]>())
+    return data.get<u16>().toString()
   }
   // @ts-ignore
-  else if (data.type === arrayU16Id) {
+  else if (data.type === unknownTypes.u32) {
     // @ts-ignore
-    return serializeNumberArray<u16[]>(data.get<u16[]>())
+    return data.get<u32>().toString()
   }
   // @ts-ignore
-  else if (data.type === arrayU32Id) {
+  else if (data.type === unknownTypes.u64) {
     // @ts-ignore
-    return serializeNumberArray<u32[]>(data.get<u32[]>())
+    return data.get<u64>().toString()
   }
   // @ts-ignore
-  else if (data.type === arrayU64Id) {
+  else if (data.type === unknownTypes.f32) {
     // @ts-ignore
-    return serializeNumberArray<u64[]>(data.get<u64[]>())
+    return data.get<f32>().toString()
   }
   // @ts-ignore
-  else if (data.type === arrayI8Id) {
+  else if (data.type === unknownTypes.f64) {
     // @ts-ignore
-    return serializeNumberArray<i8[]>(data.get<i8[]>())
+    return data.get<f64>().toString()
   }
   // @ts-ignore
-  else if (data.type === arrayI16Id) {
+  else if (data.type === objectId) {
     // @ts-ignore
-    return serializeNumberArray<i16[]>(data.get<i16[]>())
+    return serializeDynamicObject(data.get<DynamicObject>())
   }
   // @ts-ignore
-  else if (data.type === arrayI32Id) {
+  else if (data.type === arrayUnknownId) {
     // @ts-ignore
-    return serializeNumberArray<i32[]>(data.get<i32[]>())
+    return serializeUnknownArray(data.get<unknown[]>())
   }
   // @ts-ignore
-  else if (data.type === arrayI64Id) {
+  else if (data.type === arrayBoolId) {
     // @ts-ignore
-    return serializeNumberArray<i64[]>(data.get<i64[]>())
+    return serializeBooleanArray(data.get<bool[]>())
   }
   // @ts-ignore
-  else if (data.type === arrayStringId) {
+  else if (data.type === arrayBooleanId) {
     // @ts-ignore
-    return serializeStringArray(data.get<string[]>())
+    return serializeBooleanArray(data.get<boolean[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.boolean) {
+  else if (data.type === arrayF32Id) {
     // @ts-ignore
-    return serializeBoolean(data.get<boolean>())
+    return serializeNumberArray<f32[]>(data.get<f32[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.i8) {
+  else if (data.type === arrayF64Id) {
     // @ts-ignore
-    return data.get<i8>().toString()
+    return serializeNumberArray<f64[]>(data.get<f64[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.i16) {
+  else if (data.type === arrayU8Id) {
     // @ts-ignore
-    return data.get<i16>().toString()
+    return serializeNumberArray<u8[]>(data.get<u8[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.i32) {
+  else if (data.type === arrayU16Id) {
     // @ts-ignore
-    return data.get<i32>().toString()
+    return serializeNumberArray<u16[]>(data.get<u16[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.i64) {
+  else if (data.type === arrayU32Id) {
     // @ts-ignore
-    return data.get<i64>().toString()
+    return serializeNumberArray<u32[]>(data.get<u32[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.u8) {
+  else if (data.type === arrayU64Id) {
     // @ts-ignore
-    return data.get<u8>().toString()
+    return serializeNumberArray<u64[]>(data.get<u64[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.u16) {
+  else if (data.type === arrayI8Id) {
     // @ts-ignore
-    return data.get<u16>().toString()
+    return serializeNumberArray<i8[]>(data.get<i8[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.u32) {
+  else if (data.type === arrayI16Id) {
     // @ts-ignore
-    return data.get<u32>().toString()
+    return serializeNumberArray<i16[]>(data.get<i16[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.u64) {
+  else if (data.type === arrayI32Id) {
     // @ts-ignore
-    return data.get<u64>().toString()
+    return serializeNumberArray<i32[]>(data.get<i32[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.f32) {
+  else if (data.type === arrayI64Id) {
     // @ts-ignore
-    return data.get<f32>().toString()
+    return serializeNumberArray<i64[]>(data.get<i64[]>())
   }
   // @ts-ignore
-  else if (data.type === unknownTypes.f64) {
+  else if (data.type === arrayStringId) {
     // @ts-ignore
-    return data.get<f64>().toString()
+    return serializeStringArray(data.get<string[]>())
   }
   // @ts-ignore
   else {
@@ -377,7 +377,7 @@ function serializeObjectArray<T extends Array<any>>(data: T): string {
   return result.toString()
 }
 
-function serializeDynamicObjectArray(data: Object[]): string {
+function serializeDynamicObjectArray(data: DynamicObject[]): string {
   const result = new StringSink(lbracket)
   const len: u32 = data.length - 1
   for (let i: u32 = 0; i < len; i++) {
@@ -436,7 +436,7 @@ export function serializeArray<T extends Array<any>>(data: T): string {
     result.writeCodePoint(rbracketCode)
     return result.toString()
     // @ts-ignore
-  } else if (type instanceof Object) {
+  } else if (type instanceof DynamicObject) {
     for (let i = 0; i < len; i++) {
       result.write(serializeDynamicObject(unchecked(data[i])))
       result.writeCodePoint(commaCode)
@@ -712,9 +712,9 @@ export function parseObject<T>(data: string): T {
   return schema.__decode(result)
 }
 
-export function parseDynamicObject(data: string): Object {
+export function parseDynamicObject(data: string): DynamicObject {
   const len: u32 = data.length - 1
-  if (len === 1) return new Object()
+  if (len === 1) return new DynamicObject()
   const result = new Map<string, unknown>()
   let lastPos: u32 = 1
   let key: string = ''
@@ -750,7 +750,7 @@ export function parseDynamicObject(data: string): Object {
   }
 
   if ((len - lastPos) > 0) result.set(key, unknown.wrap(data.slice(lastPos + 1, len - 1).trim()))
-  const o = new Object()
+  const o = new DynamicObject()
   // @ts-ignore
   o.__data = result
   return o

package/assembly/test.ts

@@ -2,10 +2,10 @@ import { unknown, unknownTypes } from './unknown'
 
 import { console, stringify } from "../node_modules/as-console/assembly/wasi"
 
-import { JSON, parseDynamicObject, parseUnknown, parseUnknownArray } from './json'
-
-import { Object } from './Object'
+import { JSON, parseDynamicObject, parseUnknown, parseUnknownArray } from '.'
 
+import { DynamicObject } from './DynamicObject'
+/*
 // Not inlining results in an error for some reason
 // @ts-ignore
 @inline
@@ -180,3 +180,13 @@ check<string[][]>('Encode/Decode string[][]', [['Hey'], ['ha'], ['ho']])
 check<JSONSchema>('Encode/Decode object', obj)
 
 check<EmptySchema>('Encode/Decode object', emptyObj)
+*/
+// Unknown
+//check<unknown[]>('Encode/Decode unknown[]', ["Welcome to dynamic arrays", ["Very", ["Deep", ["Array"]]], "It also supports nulls"])
+
+//console.log(JSON.stringify(["Welcome to dynamic arrays", 3.14, ["Very", ["Deep", ["Array"]]], true, "It also supports nulls", null]))
+
+//console.log(JSON.stringify(JSON.parse<unknown[]>('["Welcome to dynamic arrays",3.14,["Very",["Deep",["Array"]]],true,"It also supports nulls",null]')))
+const foo = new Map()
+
+//console.log(JSON.stringify(parseDynamicObject('{"hello":"world"}')))

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "json-as",
-  "version": "0.1.9",
+  "version": "0.2.3",
   "description": "JSON encoder/decoder for AssemblyScript",
-  "types": "assembly/json.ts",
-  "ascMain": "assembly/json.ts",
+  "types": "assembly/index.ts",
+  "ascMain": "assembly/index.ts",
   "author": "JairusSW",
   "license": "MIT",
   "scripts": {
@@ -22,24 +22,23 @@
     "@as-pect/cli": "^6.2.4",
     "@assemblyscript/loader": "^0.19.10",
     "@serial-as/json": "^1.0.2",
-    "@types/jest": "^26.0.24",
+    "@types/jest": "^27.0.2",
     "@types/line-column": "^1.0.0",
     "as-base64": "^0.2.0",
     "as-bignum": "^0.2.18",
     "as-console": "^6.0.2",
-    "as-string-sink": "^0.4.2",
     "as-variant": "^0.2.1",
     "as-wasi": "^0.4.6",
     "asbuild": "^0.2.0",
-    "assemblyscript": "^0.19.10",
+    "assemblyscript": "^0.19.18",
     "assemblyscript-json": "^1.1.0",
-    "jest": "^27.0.6",
-    "kati": "^0.5.1",
+    "jest": "^27.3.1",
+    "kati": "^0.6.2",
     "lerna": "^4.0.0",
     "rimraf": "^3.0.2",
-    "ts-jest": "^27.0.4",
-    "ts-node": "^10.1.0",
-    "typescript": "^4.3.5"
+    "ts-jest": "^27.0.7",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.4.4"
   },
   "dependencies": {},
   "repository": {

package/transform/lib/index.js

@@ -3,7 +3,7 @@ const as_1 = require("visitor-as/as");
 const visitor_as_1 = require("visitor-as");
 const utils_1 = require("visitor-as/dist/utils");
 function getTypeName(type) {
-    let _type = utils_1.getName(type);
+    let _type = (0, utils_1.getName)(type);
     const OR_NULL = /\|.*null/;
     if (type.isNullable && !OR_NULL.test(_type)) {
         _type = `${_type} | null`;
@@ -29,9 +29,9 @@ class JSONTransformer extends visitor_as_1.BaseVisitor {
     }
     visitElementAccessExpression(node) {
         super.visitElementAccessExpression(node);
-        if (utils_1.toString(node.expression) === 'o') {
+        if ((0, utils_1.toString)(node.expression) === 'o') {
             // Should be like if (node.expression.type.text === "Object") {
-            const replacer = visitor_as_1.SimpleParser.parseExpression(`u32(changetype<usize>(${utils_1.toString(node.elementExpression)}))`);
+            const replacer = visitor_as_1.SimpleParser.parseExpression(`u32(changetype<usize>(${(0, utils_1.toString)(node.elementExpression)}))`);
             node.elementExpression = replacer;
             this.sources.push(replacer.range.source);
         }
@@ -49,7 +49,7 @@ class JSONTransformer extends visitor_as_1.BaseVisitor {
                     this.convertToAnyArray(expr.elementExpressions);
                 }
                 // @ts-ignore
-                replacement = visitor_as_1.SimpleParser.parseExpression(`unknown.wrap(${utils_1.toString(expr)})`);
+                replacement = visitor_as_1.SimpleParser.parseExpression(`unknown.wrap(${(0, utils_1.toString)(expr)})`);
                 node.elementExpressions[i] = replacement;
                 this.sources.push(replacement.range.source);
             }
@@ -66,14 +66,14 @@ class JSONTransformer extends visitor_as_1.BaseVisitor {
                 this.convertToAnyArray(expr.elementExpressions);
             }
             // @ts-ignore
-            replacement = visitor_as_1.SimpleParser.parseExpression(`unknown.wrap(${utils_1.toString(expr)})`);
+            replacement = visitor_as_1.SimpleParser.parseExpression(`unknown.wrap(${(0, utils_1.toString)(expr)})`);
             exprs[i] = replacement;
             this.sources.push(replacement.range.source);
         }
     }
     visitFieldDeclaration(node) {
         super.visitFieldDeclaration(node);
-        const name = utils_1.toString(node.name);
+        const name = (0, utils_1.toString)(node.name);
         if (!node.type) {
             throw new Error(`Field ${name} is missing a type declaration`);
         }
@@ -96,7 +96,7 @@ class JSONTransformer extends visitor_as_1.BaseVisitor {
             return;
         }
         this.currentClass = node;
-        const name = utils_1.getName(node);
+        const name = (0, utils_1.getName)(node);
         this.encodeStmts.delete(name);
         this.decodeCode.delete(name);
         this.visit(node.members);
@@ -146,10 +146,10 @@ function isanyArray(node) {
     if (node.elementExpressions.length === 0)
         return false;
     const firstKind = node.elementExpressions[0]?.kind;
-    const isBoolean = (utils_1.toString(node.elementExpressions[0]) === 'true' || utils_1.toString(node.elementExpressions[0]) === 'false');
+    const isBoolean = ((0, utils_1.toString)(node.elementExpressions[0]) === 'true' || (0, utils_1.toString)(node.elementExpressions[0]) === 'false');
     for (const chunk of node.elementExpressions) {
         if (isBoolean) {
-            if (utils_1.toString(chunk) !== 'true' || utils_1.toString(chunk) !== 'false')
+            if ((0, utils_1.toString)(chunk) !== 'true' || (0, utils_1.toString)(chunk) !== 'false')
                 true;
         }
         else if (chunk.kind !== firstKind)

package/assembly/Object.ts

@@ -1,28 +0,0 @@
-import { unknown } from "./unknown"
-
-/**
- * Provides functionality common to all JavaScript objects.
- */
-export class Object {
-    [key: string]: any
-    // Having it marked as 'any' is for intellisense only
-    protected __data: Map<string, unknown> = new Map<string, unknown>()
-    @operator('[]')
-    private __getKeyOp(key: usize): unknown {
-        if (this.__data.has(changetype<string>(key))) {
-            return this.__data.get(changetype<string>(key))
-        } else {
-            return unknown.wrap(null)
-        }
-    }
-    @operator('[]=')
-    private __setKeyOp(key: usize, value: unknown): void {
-        this.__data.set(changetype<string>(key), value)
-    }
-    static keys(o: Object): string[] {
-        return o.__data.keys()
-    }
-    static values(o: Object): unknown[] {
-        return o.__data.values()
-    }
-}