json-as 0.8.7 → 0.8.8

package/transform/lib/index.js

@@ -1,8 +1,20 @@
-import { FieldDeclaration, } from "assemblyscript/dist/assemblyscript.js";
+import { Parser, Source, Tokenizer, } from "assemblyscript/dist/assemblyscript.js";
 import { toString, isStdlib } from "visitor-as/dist/utils.js";
 import { BaseVisitor, SimpleParser } from "visitor-as/dist/index.js";
 import { Transform } from "assemblyscript/dist/transform.js";
-class JSONTransform extends BaseVisitor {
+class SchemaData {
+    constructor() {
+        this.keys = [];
+        this.values = [];
+        this.types = [];
+        this.name = "";
+        this.parent = "";
+        this.encodeStmts = [];
+        this.setDataStmts = [];
+        this.initializeStmts = [];
+    }
+}
+class AsJSONTransform extends BaseVisitor {
     constructor() {
         super(...arguments);
         this.schemasList = [];
@@ -10,265 +22,175 @@ class JSONTransform extends BaseVisitor {
     }
     visitMethodDeclaration() { }
     visitClassDeclaration(node) {
-        if (!node.decorators?.length)
-            return;
-        if (!node.members?.length)
+        var _c, _d;
+        const className = node.name.text;
+        if (!((_c = node.decorators) === null || _c === void 0 ? void 0 : _c.length))
             return;
-        let found = false;
+        let foundDecorator = false;
         for (const decorator of node.decorators) {
-            const name = decorator.name.text;
-            if (name === "json" || name === "serializable") {
-                found = true;
-                break;
-            }
+            if (
+            // @ts-ignore
+            decorator.name.text.toLowerCase() == "json" ||
+                // @ts-ignore
+                decorator.name.text.toLowerCase() == "serializable")
+                foundDecorator = true;
         }
-        if (!found)
+        if (!foundDecorator)
             return;
-        const schema = new SchemaData();
-        schema.node = node;
-        schema.name = node.name.text;
-        const members = [
-            ...node.members
-        ];
-        if (node.extendsType) {
-            schema.parent = this.schemasList.find((v) => v.name == node.extendsType?.name.identifier.text);
-            if (schema.parent?.members) {
-                for (let i = 0; i < schema.parent.members.length; i++) {
-                    const replace = schema.members.find((v) => v.name == schema.parent?.members[i]?.name);
-                    if (!replace)
-                        schema.members.unshift(schema.parent.members[i]);
-                }
-            }
+        // Prevent from being triggered twice.
+        for (const member of node.members) {
+            if (member.name.text == "__SERIALIZE")
+                return;
         }
-        for (const member of members) {
-            if (!(member instanceof FieldDeclaration))
-                continue;
-            const name = member.name;
-            if (!member.type) {
-                throw new Error("Fields must be strongly typed! Found " + toString(member) + " at " + node.range.source.normalizedPath);
-            }
-            const type = toString(member.type);
-            const value = member.initializer ? toString(member.initializer) : null;
-            if (member.flags == 32 /* CommonFlags.Static */)
-                continue;
-            if (member.flags === 512 /* CommonFlags.Private */)
-                continue;
-            if (member.flags === 1024 /* CommonFlags.Protected */)
-                continue;
-            const mem = new Property();
-            mem.name = name.text;
-            mem.type = type;
-            mem.value = value;
-            mem.node = member;
-            for (const decorator of member.decorators || []) {
-                if (decorator.name.text == "alias") {
-                    if (!decorator.args?.length)
-                        throw new Error("Expected 1 argument but got zero at @alias in " + node.range.source.normalizedPath);
-                    mem.flag = PropertyFlags.Alias;
-                    mem.alias = decorator.args[0].value;
-                }
-                else if (decorator.name.text == "omit") {
-                    mem.flag = PropertyFlags.Omit;
+        this.currentClass = {
+            name: className,
+            keys: [],
+            values: [],
+            types: [],
+            parent: node.extendsType ? toString(node.extendsType) : "",
+            node: node,
+            encodeStmts: [],
+            setDataStmts: [],
+            initializeStmts: []
+        };
+        if (this.currentClass.parent.length) {
+            const parentSchema = this.schemasList.find((v) => v.name == this.currentClass.parent);
+            if (parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.encodeStmts) {
+                parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.encodeStmts.push((parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.encodeStmts.pop()) + ",");
+                for (let i = 0; i < parentSchema.keys.length; i++) {
+                    const key = parentSchema.keys[i];
+                    if (node.members.filter(v => v.name.text == key) == undefined)
+                        this.currentClass.encodeStmts.unshift(parentSchema.encodeStmts[i]);
                 }
-                else if (decorator.name.text == "omitnull") {
-                    mem.flag = PropertyFlags.OmitNull;
-                }
-                else if (decorator.name.text == "omitif") {
-                    if (!decorator.args?.length)
-                        throw new Error("Expected 1 argument but got zero at @omitif in " + node.range.source.normalizedPath);
-                    mem.args?.push(decorator.args[0].value);
-                    mem.flag = PropertyFlags.OmitIf;
-                }
-            }
-            if (mem.flag === PropertyFlags.Alias) {
-                mem.name = mem.alias;
-            }
-            else if (mem.flag === PropertyFlags.None) {
-                mem.serialize = escapeString(JSON.stringify(mem.name)) + ":${__SERIALIZE<" + type + ">(this." + name.text + ")}";
-                mem.deserialize = "this." + name.text + " = " + "__DESERIALIZE<" + type + ">(data.substring(value_start, value_end));";
-            }
-            if (mem.flag == PropertyFlags.OmitNull) {
-                mem.serialize = "${changetype<usize>(this." + mem.name + ") == <usize>0" + " ? \"\" : '" + escapeString(JSON.stringify(mem.name)) + ":' + __SERIALIZE<" + type + ">(this." + name.text + ") + \",\"}";
-                mem.deserialize = "this." + name.text + " = " + "__DESERIALIZE<" + type + ">(data.substring(value_start, value_end));";
-            }
-            else if (mem.flag == PropertyFlags.OmitIf) {
-                mem.serialize = "${" + mem.args[0] + " ? \"\" : '" + escapeString(JSON.stringify(mem.name)) + ":' + __SERIALIZE<" + type + ">(this." + name.text + ")}";
-                mem.deserialize = "this." + name.text + " = " + "__DESERIALIZE<" + type + ">(data.substring(value_start, value_end));";
-            }
-            else if (mem.flag == PropertyFlags.Alias) {
-                mem.serialize = escapeString(JSON.stringify(mem.name)) + ":${__SERIALIZE<" + type + ">(this." + name.text + ")}";
-                mem.deserialize = "this." + name.text + " = " + "__DESERIALIZE<" + type + ">(data.substring(value_start, value_end));";
-                mem.name = name.text;
-            }
-            const t = mem.node.type.name.identifier.text;
-            if (this.schemasList.find(v => v.name == t)) {
-                mem.initialize = "this." + name.text + " = changetype<nonnull<" + t + ">>(__new(offsetof<nonnull<" + t + ">>(), idof<nonnull<" + t + ">>()));\n  changetype<nonnull<" + t + ">>(this." + name.text + ").__INITIALIZE()";
             }
-            else if (mem.value) {
-                mem.initialize = "this." + name.text + " = " + mem.value;
-            }
-            schema.members.push(mem);
-        }
-        let SERIALIZE_RAW = "@inline __SERIALIZE(): string {\n  let out = `{";
-        let SERIALIZE_PRETTY = "@inline __SERIALIZE_PRETTY(): string {\n  let out = `{";
-        let INITIALIZE = "@inline __INITIALIZE(): this {\n";
-        let DESERIALIZE = "@inline __DESERIALIZE(data: string, key_start: i32, key_end: i32, value_start: i32, value_end: i32): boolean {\n  const len = key_end - key_start;\n";
-        let indent = "  ";
-        if (!schema.members.length)
-            return;
-        found = false;
-        if (schema.members[0]?.flag === PropertyFlags.OmitNull
-            || schema.members[0]?.flag === PropertyFlags.OmitIf) {
-            SERIALIZE_RAW += schema.members[0]?.serialize;
-            SERIALIZE_PRETTY += "\\n" + schema.members[0]?.serialize;
-        }
-        else {
-            SERIALIZE_RAW += schema.members[0]?.serialize + ",";
-            SERIALIZE_PRETTY += "\\n" + schema.members[0]?.serialize + ",\\n";
-            found = true;
-        }
-        if (schema.members[0]?.initialize)
-            INITIALIZE += "  " + schema.members[0]?.initialize + ";\n";
-        for (let i = 1; i < schema.members.length; i++) {
-            const member = schema.members[i];
-            if (member.initialize)
-                INITIALIZE += "  " + member.initialize + ";\n";
-            if (member.flag === PropertyFlags.OmitNull
-                || member.flag === PropertyFlags.OmitIf) {
-                SERIALIZE_RAW += member.serialize;
-                SERIALIZE_PRETTY += member.serialize;
-            }
-            else {
-                SERIALIZE_RAW += member.serialize + ",";
-                SERIALIZE_PRETTY += indent + member.serialize + ",\\n";
-                found = true;
-            }
-        }
-        if (found) {
-            SERIALIZE_RAW += "`;\n  store<u16>(changetype<usize>(out) + ((out.length - 1) << 1), 125);\n  return out;\n}";
-            SERIALIZE_PRETTY += "`;\n  store<u32>(changetype<usize>(out) + ((out.length - 2) << 1), 8192010);\n  return out;\n}";
-        }
-        else {
-            SERIALIZE_RAW += "`;\n};";
-            SERIALIZE_PRETTY += "`;\n};";
         }
-        INITIALIZE += "  return this;\n}";
-        const sortedMembers = [];
-        const _sorted = schema.members.sort((a, b) => a.name.length - b.name.length);
-        let len = 0;
-        let offset = 0;
-        sortedMembers.push([_sorted[0]]);
-        len = _sorted[0]?.name.length;
-        for (let i = 1; i < _sorted.length; i++) {
-            const member = _sorted[i];
-            if (member.alias?.length || member.name.length > len) {
-                sortedMembers.push([member]);
-                len = member.alias?.length || member.name.length;
-                offset++;
-            }
-            else {
-                sortedMembers[offset].push(member);
+        const parentSchema = this.schemasList.find((v) => v.name == this.currentClass.parent);
+        const members = [
+            ...node.members
+        ];
+        if (parentSchema) {
+            for (const mem of parentSchema.node.members) {
+                if (members.find(v => v.name === mem.name) == undefined)
+                    members.unshift(mem);
             }
         }
-        let first = true;
-        for (const memberSet of sortedMembers) {
-            const firstMember = memberSet[0];
-            const name = encodeKey(firstMember.alias || firstMember.name);
-            if (name.length === 1) {
-                if (first) {
-                    DESERIALIZE += "  if (1 === len) {\n    switch (load<u16>(changetype<usize>(data) + (key_start << 1))) {\n";
-                    first = false;
-                }
-                else {
-                    DESERIALIZE += "else if (1 === len) {\n    switch (load<u16>(changetype<usize>(data) + (key_start << 1))) {\n";
-                }
-            }
-            else if (name.length === 2) {
-                if (first) {
-                    DESERIALIZE += "  if (2 === len) {\n    switch (load<u32>(changetype<usize>(data) + (key_start << 1))) {\n";
-                    first = false;
-                }
-                else {
-                    DESERIALIZE += "else if (2 === len) {\n    switch (load<u32>(changetype<usize>(data) + (key_start << 1))) {\n";
-                }
-            }
-            else if (name.length === 4) {
-                if (first) {
-                    DESERIALIZE += "  if (4 === len) {\n    const code = load<u64>(changetype<usize>(data) + (key_start << 1));\n";
-                    first = false;
-                }
-                else {
-                    DESERIALIZE += "else if (4 === len) {\n    const code = load<u64>(changetype<usize>(data) + (key_start << 1));\n";
-                }
-            }
-            else {
-                if (first) {
-                    DESERIALIZE += "  if (" + name.length + " === len) {\n";
-                    first = false;
-                }
-                else {
-                    DESERIALIZE += "else if (" + name.length + " === len) {\n";
-                }
-            }
-            let f = true;
-            for (let i = 0; i < memberSet.length; i++) {
-                const member = memberSet[i];
-                const name = encodeKey(member.alias || member.name);
-                if (name.length === 1) {
-                    DESERIALIZE += `      case ${name.charCodeAt(0)}: {\n        ${member.deserialize}\n        return true;\n      }\n`;
-                }
-                else if (name.length === 2) {
-                    DESERIALIZE += `      case ${charCodeAt32(name, 0)}: {\n        ${member.deserialize}\n        return true;\n      }\n`;
-                }
-                else if (name.length === 4) {
-                    if (f) {
-                        f = false;
-                        DESERIALIZE += `    if (${charCodeAt64(name, 0)} === code) {\n      ${member.deserialize}\n      return true;\n    }\n`;
+        for (const mem of members) {
+            // @ts-ignore
+            if (mem.type && mem.type.name && mem.type.name.identifier.text) {
+                const member = mem;
+                const lineText = toString(member);
+                //console.log("Member: " + lineText)
+                if (!lineText.startsWith("private ") && !lineText.startsWith("static ")) {
+                    // @ts-ignore
+                    let type = toString(member.type);
+                    const name = member.name.text;
+                    let aliasName = name;
+                    // @ts-ignore
+                    if (member.decorators && ((_d = member.decorators[0]) === null || _d === void 0 ? void 0 : _d.name.text) === "alias") {
+                        if (member.decorators[0] && member.decorators[0].args[0]) {
+                            // @ts-ignore
+                            aliasName = member.decorators[0].args[0].value;
+                        }
                     }
-                    else {
-                        DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + `else if (${charCodeAt64(name, 0)} === code) {\n      ${member.deserialize}\n      return true;\n    }\n`;
+                    this.currentClass.keys.push(name);
+                    // @ts-ignore
+                    this.currentClass.types.push(type);
+                    // @ts-ignore
+                    if ([
+                        "u8",
+                        "i8",
+                        "u16",
+                        "i16",
+                        "u32",
+                        "i32",
+                        "u64",
+                        "i64",
+                    ].includes(type.toLowerCase())) {
+                        this.currentClass.encodeStmts.push(`${encodeKey(aliasName)}:\${this.${name}},`);
+                        // @ts-ignore
+                        this.currentClass.setDataStmts.push(`if (key.equals(${JSON.stringify(aliasName)})) {
+          this.${name} = __atoi_fast<${type}>(data, val_start << 1, val_end << 1);
+          return;
+        }`);
+                        if (member.initializer) {
+                            this.currentClass.initializeStmts.push(`this.${name} = ${toString(member.initializer)}`);
+                        }
                     }
-                }
-                else {
-                    if (f) {
-                        f = false;
-                        DESERIALIZE += `    if (0 == memory.compare(changetype<usize>("${escapeQuote(escapeSlash(name))}"), changetype<usize>(data) + (key_start << 1), ${name.length << 1})) {\n      ${member.deserialize}\n      return true;\n    }\n`;
+                    else // @ts-ignore
+                     if ([
+                        "f32",
+                        "f64",
+                    ].includes(type.toLowerCase())) {
+                        this.currentClass.encodeStmts.push(`${encodeKey(aliasName)}:\${this.${name}},`);
+                        // @ts-ignore
+                        this.currentClass.setDataStmts.push(`if (key.equals(${JSON.stringify(aliasName)})) {
+            this.${name} = __parseObjectValue<${type}>(data.slice(val_start, val_end), initializeDefaultValues);
+            return;
+          }`);
+                        if (member.initializer) {
+                            this.currentClass.initializeStmts.push(`this.${name} = ${toString(member.initializer)}`);
+                        }
                     }
                     else {
-                        DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + ` else if (0 == memory.compare(changetype<usize>("${escapeQuote(escapeSlash(name))}"), changetype<usize>(data) + (key_start << 1), ${name.length << 1})) {\n      ${member.deserialize}\n      return true;\n    }\n`;
+                        this.currentClass.encodeStmts.push(`${encodeKey(aliasName)}:\${__JSON_Stringify<${type}>(this.${name})},`);
+                        // @ts-ignore
+                        this.currentClass.setDataStmts.push(`if (key.equals(${JSON.stringify(aliasName)})) {
+            this.${name} = __parseObjectValue<${type}>(val_start ? data.slice(val_start, val_end) : data, initializeDefaultValues);
+            return;
+          }`);
+                        if (member.initializer) {
+                            this.currentClass.initializeStmts.push(`this.${name} = ${toString(member.initializer)}`);
+                        }
                     }
                 }
             }
-            if (name.length < 3) {
-                DESERIALIZE += `      default: {\n        return false;\n      }\n    }\n`;
-            }
-            else if (name.length == 4) {
-                DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + ` else {\n      return false;\n    }\n`;
-            }
-            else {
-                DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + ` else {\n      return false;\n    }\n`;
-            }
-            DESERIALIZE += "  } ";
         }
-        DESERIALIZE += "\n  return false;\n}";
-        //console.log(sortedMembers);
-        if (process.env["JSON_DEBUG"]) {
-            console.log(SERIALIZE_RAW);
-            //console.log(SERIALIZE_PRETTY);
-            console.log(INITIALIZE);
-            console.log(DESERIALIZE);
+        let serializeFunc = "";
+        if (this.currentClass.encodeStmts.length > 0) {
+            const stmt = this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1];
+            this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1] =
+                stmt.slice(0, stmt.length - 1);
+            serializeFunc = `
+      __SERIALIZE(): string {
+        return \`{${this.currentClass.encodeStmts.join("")}}\`;
+      }`;
+        }
+        else {
+            serializeFunc = `
+      __SERIALIZE(): string {
+        return "{}";
+      }`;
         }
-        const SERIALIZE_RAW_METHOD = SimpleParser.parseClassMember(SERIALIZE_RAW, node);
-        //const SERIALIZE_PRETTY_METHOD = SimpleParser.parseClassMember(SERIALIZE_PRETTY, node);
-        const INITIALIZE_METHOD = SimpleParser.parseClassMember(INITIALIZE, node);
-        const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE, node);
-        if (!node.members.find(v => v.name.text == "__SERIALIZE"))
-            node.members.push(SERIALIZE_RAW_METHOD);
-        if (!node.members.find(v => v.name.text == "__INITIALIZE"))
-            node.members.push(INITIALIZE_METHOD);
-        if (!node.members.find(v => v.name.text == "__DESERIALIZE"))
-            node.members.push(DESERIALIZE_METHOD);
-        this.schemasList.push(schema);
+        const setKeyFunc = `
+      __JSON_Set_Key(key: __Virtual<string>, data: string, val_start: i32, val_end: i32, initializeDefaultValues: boolean): void {
+        ${this.currentClass.setDataStmts.join("\n        ")}
+      }
+    `;
+        let initializeFunc = "";
+        if (this.currentClass.initializeStmts.length > 0) {
+            initializeFunc = `
+      __JSON_Initialize(): void {
+      ${this.currentClass.initializeStmts.join(";\n")};
+      }
+      `;
+        }
+        else {
+            initializeFunc = `
+      __JSON_Initialize(): void {}
+      `;
+        }
+        const serializeMethod = SimpleParser.parseClassMember(serializeFunc, node);
+        node.members.push(serializeMethod);
+        const setDataMethod = SimpleParser.parseClassMember(setKeyFunc, node);
+        node.members.push(setDataMethod);
+        const initializeMethod = SimpleParser.parseClassMember(initializeFunc, node);
+        node.members.push(initializeMethod);
+        this.schemasList.push(this.currentClass);
+        this.sources.add(node.name.range.source);
+        // Uncomment to see the generated code for debugging.
+        //console.log(serializeFunc);
+        //console.log(setKeyFunc);
+        //console.log(initializeFunc);
     }
     visitSource(node) {
         super.visitSource(node);
@@ -276,13 +198,30 @@ class JSONTransform extends BaseVisitor {
         if (!this.sources.has(node)) {
             return;
         }
+        // Note, the following one liner would be easier, but it fails with an assertion error
+        // because as-virtual's SimpleParser doesn't set the parser.currentSource correctly.
+        //
+        // const stmt = SimpleParser.parseTopLevelStatement('import { Virtual as __Virtual } from "as-virtual/assembly";');
+        // ... So we have to do it the long way:
+        const txt = 'import { Virtual as __Virtual } from "as-virtual/assembly";';
+        const tokenizer = new Tokenizer(new Source(0 /* SourceKind.User */, node.normalizedPath, txt));
+        const parser = new Parser();
+        parser.currentSource = tokenizer.source;
+        const stmt = parser.parseTopLevelStatement(tokenizer);
+        // Add the import statement to the top of the source.
+        node.statements.unshift(stmt);
     }
 }
+function encodeKey(aliasName) {
+    return JSON.stringify(aliasName)
+        .replace(/\\/g, "\\\\")
+        .replace(/\`/g, '\\`');
+}
 export default class Transformer extends Transform {
     // Trigger the transform after parse.
     afterParse(parser) {
         // Create new transform
-        const transformer = new JSONTransform();
+        const transformer = new AsJSONTransform();
         // Sort the sources so that user scripts are visited last
         const sources = parser.sources
             .filter((source) => !isStdlib(source))
@@ -310,67 +249,10 @@ export default class Transformer extends Transform {
         const schemas = transformer.schemasList;
         for (const schema of schemas) {
             if (schema.parent) {
-                const parent = schemas.find((v) => v.name === schema.parent?.name);
+                const parent = schemas.find((v) => v.name === schema.parent);
                 if (!parent)
                     throw new Error(`Class ${schema.name} extends its parent class ${schema.parent}, but ${schema.parent} does not include a @json or @serializable decorator! Add the decorator and rebuild.`);
             }
         }
     }
 }
-var PropertyFlags;
-(function (PropertyFlags) {
-    PropertyFlags[PropertyFlags["None"] = 0] = "None";
-    PropertyFlags[PropertyFlags["Omit"] = 1] = "Omit";
-    PropertyFlags[PropertyFlags["OmitNull"] = 2] = "OmitNull";
-    PropertyFlags[PropertyFlags["OmitIf"] = 3] = "OmitIf";
-    PropertyFlags[PropertyFlags["Alias"] = 4] = "Alias";
-})(PropertyFlags || (PropertyFlags = {}));
-class Property {
-    constructor() {
-        this.name = "";
-        this.alias = null;
-        this.type = "";
-        this.value = null;
-        this.flag = PropertyFlags.None;
-        this.args = [];
-        this.serialize = null;
-        this.deserialize = null;
-        this.initialize = null;
-    }
-}
-class SchemaData {
-    constructor() {
-        this.name = "";
-        this.members = [];
-        this.parent = null;
-    }
-}
-function charCodeAt32(data, offset) {
-    return (data.charCodeAt(offset + 1) << 16) | data.charCodeAt(offset);
-}
-function charCodeAt64(data, offset) {
-    if (offset + 3 >= data.length) {
-        throw new Error("The string must have at least 4 characters from the specified offset.");
-    }
-    const firstCharCode = BigInt(data.charCodeAt(offset));
-    const secondCharCode = BigInt(data.charCodeAt(offset + 1));
-    const thirdCharCode = BigInt(data.charCodeAt(offset + 2));
-    const fourthCharCode = BigInt(data.charCodeAt(offset + 3));
-    const u64Value = (fourthCharCode << 48n) | (thirdCharCode << 32n) | (secondCharCode << 16n) | firstCharCode;
-    return u64Value;
-}
-function encodeKey(key) {
-    const data = JSON.stringify(key);
-    return data.slice(1, data.length - 1);
-}
-function escapeString(data) {
-    return data.replace(/\\/g, "\\\\")
-        .replace(/\`/g, '\\`');
-}
-function escapeSlash(data) {
-    return data.replace(/\\/g, "\\\\")
-        .replace(/\`/g, '\\`');
-}
-function escapeQuote(data) {
-    return data.replace(/\"/g, "\\\"");
-}

package/transform/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-as/transform",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "description": "JSON encoder/decoder for AssemblyScript",
   "main": "./lib/index.js",
   "author": "Jairus Tanaka",