json-as 0.2.6 → 0.4.2

package/transform/src/index.old.js

@@ -0,0 +1,430 @@
+/*import {
+  IdentifierExpression,
+  Parser,
+  ClassDeclaration,
+  CommonFlags,
+  TypeName,
+  NamedTypeNode,
+  VariableLikeDeclarationStatement,
+  DiagnosticCode,
+  ObjectLiteralExpression,
+  Expression,
+  Range,
+  ParameterKind,
+  Statement,
+} from "assemblyscript";
+import { Transform } from "assemblyscript/transform";
+
+export default class MyTransform extends Transform {
+  // @ts-ignore
+  readFile(filename: string, baseDir: string) {
+    return null;
+  }
+  afterParse(p: Parser) {
+    p.sources.forEach((s) => {
+      if (s.isLibrary) return;
+      s.statements.forEach((s) => {
+        if (s instanceof ClassDeclaration) {
+          let __DECOR;
+          if (
+            __DECOR = s.decorators?.find(
+              (d) =>
+                d.name instanceof IdentifierExpression && d.name.text == "json"
+            )
+          ) {
+            const __DEFAULT_RANGE = __DECOR.range;
+            const members = s.members.filter<VariableLikeDeclarationStatement>(
+              (e): e is VariableLikeDeclarationStatement =>
+                e instanceof VariableLikeDeclarationStatement
+            );
+            members.forEach((e) => {
+              if (!e.type) {
+                p.error(
+                  DiagnosticCode.User_defined_0,
+                  e.range,
+                  "Type information must be specified for JSON serialization.", ""
+                );
+              }
+            });
+            const SimpleNames = ["u8", "u16", "string", "f32"];
+            const Param = Expression.createIdentifierExpression(
+              "param",
+              __DEFAULT_RANGE
+            );
+            const GenericMapType = Expression.createNamedType(
+              Expression.createSimpleTypeName("string", __DEFAULT_RANGE),
+              [
+                Expression.createNamedType(
+                  new TypeName(
+                    Expression.createIdentifierExpression(
+                      "JSON",
+                      __DEFAULT_RANGE
+                    ),
+                    Expression.createSimpleTypeName(
+                      "_Variant",
+                      __DEFAULT_RANGE
+                    ),
+                    __DEFAULT_RANGE
+                  ),
+                  null,
+                  false,
+                  __DEFAULT_RANGE
+                ),
+              ],
+              false,
+              __DEFAULT_RANGE
+            );
+            let kvr: [IdentifierExpression, Expression][] = [];
+
+            members.forEach((m) => {
+              if (
+                m.type instanceof NamedTypeNode &&
+                m.type.name.next == null &&
+                SimpleNames.includes(m.type.name.identifier.text)
+              ) {
+                kvr.push([
+                  Expression.createIdentifierExpression(m.name.text, m.range),
+                  Expression.createCallExpression(
+                    Expression.createElementAccessExpression(
+                      Param,
+                      Expression.createIdentifierExpression(
+                        "get",
+                        __DEFAULT_RANGE
+                      ),
+                      __DEFAULT_RANGE
+                    ),
+                    [m.type!],
+                    [],
+                    __DEFAULT_RANGE
+                  ),
+                ]);
+              } else {
+                kvr.push([
+                  Expression.createIdentifierExpression(m.name.text, m.range),
+                  Expression.createCallExpression(
+                    Expression.createPropertyAccessExpression(
+                      m.type!,
+                      Expression.createIdentifierExpression(
+                        "__Json__Deserialize",
+                        __DEFAULT_RANGE
+                      ),
+                      __DEFAULT_RANGE
+                    ),
+                    [],
+                    [
+                      Expression.createCallExpression(
+                        Expression.createElementAccessExpression(
+                          Param,
+                          Expression.createIdentifierExpression(
+                            "get",
+                            __DEFAULT_RANGE
+                          ),
+                          __DEFAULT_RANGE
+                        ),
+                        [GenericMapType],
+                        [],
+                        __DEFAULT_RANGE
+                      ),
+                    ],
+                    __DEFAULT_RANGE
+                  ),
+                ]);
+              }
+            });
+            const objectliteral = new ObjectLiteralExpression(
+              kvr.map((e) => e[0]),
+              kvr.map((e) => e[1]),
+              __DEFAULT_RANGE
+            );
+            console.log(kvr[0]?.map(e => !!e))
+            console.log(kvr[1]?.map(e => !!e))
+            s.members.push(
+              Expression.createMethodDeclaration(
+                Expression.createIdentifierExpression(
+                  "__Json__Deserialize",
+                  __DEFAULT_RANGE
+                ),
+                null,
+                CommonFlags.STATIC,
+                null,
+                Expression.createFunctionType(
+                  [
+                    Expression.createParameter(
+                      ParameterKind.DEFAULT,
+                      Expression.createIdentifierExpression(
+                        "param",
+                        __DEFAULT_RANGE
+                      ),
+                      GenericMapType,
+                      null,
+                      __DEFAULT_RANGE
+                    ),
+                  ],
+                  Expression.createNamedType(
+                    (console.log(s.name.text), Expression.createSimpleTypeName(s.name.text + '1', __DEFAULT_RANGE)),
+                    null,
+                    false,
+                    __DEFAULT_RANGE
+                  ),
+                  null,
+                  false,
+                  __DEFAULT_RANGE
+                ),
+                Statement.createBlockStatement(
+                  [
+                    Statement.createReturnStatement(
+                      objectliteral,
+                      __DEFAULT_RANGE
+                    ),
+                  ],
+                  __DEFAULT_RANGE
+                ),
+                __DEFAULT_RANGE
+              )
+            );
+          }
+        }
+      });
+    });
+  }
+}
+*/
+import {
+  ClassPrototype,
+  IdentifierExpression,
+  ImportStatement,
+  Parser,
+  Program,
+  FieldPrototype,
+  ClassDeclaration,
+  MethodDeclaration,
+  CommonFlags,
+  FunctionTypeNode,
+  TypeName,
+  BlockStatement,
+  FunctionPrototype,
+  NamedTypeNode,
+  ReturnStatement,
+  StringLiteralExpression,
+  VariableDeclaration,
+  VariableStatement,
+  BinaryExpression,
+  ExpressionStatement,
+  Token,
+  PropertyAccessExpression,
+  CallExpression,
+  ThisExpression,
+} from "assemblyscript/assemblyscript";
+import { Transform } from "assemblyscript/transform";
+import {
+  NodeKind,
+  TypeNode,
+  TypeParameterNode,
+} from "types:assemblyscript/src/ast";
+
+export default class MyTransform extends Transform {
+  readFile(filename: string, baseDir: string) {
+    return null;
+  }
+  afterParse(p: Parser) {
+    p.sources.forEach((s) => {
+      if (s.isLibrary) return;
+      s.statements.forEach((s) => {
+        if (s instanceof ImportStatement) {
+          //   console.log(s.internalPath);
+          // console.log(s.path.value.charAt(s.path.value.length - 1));
+          if (s.path.value.charAt(s.path.value.length - 1) == "~") {
+            s.path.value = s.path.value.slice(0, s.path.value.length - 1);
+            s.internalPath = s.internalPath.slice(0, s.internalPath.length - 1);
+          }
+        }
+      });
+    });
+  }
+  afterInitialize(program: Program): void {
+    // initializer(program);
+    // console.log(program.managedClasses);
+    //program.filesByName.forEach((e) => {
+    //   console.log(e.name);
+    //});
+    program.elementsByName.forEach((c) => {
+      //program.elementsByName.forEach((e) => {});
+      if (c instanceof ClassPrototype) {
+        if (
+          !!c.decoratorNodes?.find((e) => {
+            /** detect decorator */
+            return (
+              e.name instanceof IdentifierExpression && e.name.text == "json"
+            );
+          })
+        ) {
+          //   console.log({ ...c, program: {}, parent: {} });
+
+          c.members?.forEach((m) => {
+            //console.log(ElementKind[m.kind]);
+            if (m instanceof FieldPrototype) {
+              console.log(m.name);
+            }
+          });
+          let fnBody = new BlockStatement(
+            [
+              new VariableStatement(
+                null,
+                [
+                  new VariableDeclaration(
+                    new IdentifierExpression(
+                      "_str",
+                      false,
+                      c.declaration.range
+                    ),
+                    null,
+                    CommonFlags.LET,
+                    null,
+                    new StringLiteralExpression("{", c.declaration.range),
+                    c.declaration.range
+                  ),
+                ],
+                c.declaration.range
+              ),
+            ],
+            c.declaration.range
+          );
+          const escapeChars = (e: string) => {
+            let outChars = "";
+            let cchhar = "";
+            for (let i = 0; i < e.length; i++) {
+              cchhar = e.charAt(i);
+
+              if (cchhar == '"') {
+                outChars += `\\"` + cchhar;
+              } else {
+                outChars += cchhar;
+              }
+            }
+            return outChars;
+          };
+          let i = 0;
+          const size = c.instanceMembers!.size;
+          let d;
+          for (const field of c.instanceMembers!.values()) {
+            // Leave out trailing commas
+            if (i < size - 1) {
+              d = new StringLiteralExpression(",", c.declaration.range);
+            } else {
+              d = new StringLiteralExpression("", c.declaration.range);
+            }
+            if (field instanceof FieldPrototype) {
+              fnBody.statements.push(
+                new ExpressionStatement(
+                  new BinaryExpression(
+                    Token.PLUS_EQUALS,
+                    new IdentifierExpression(
+                      "_str",
+                      false,
+                      c.declaration.range
+                    ),
+                    new BinaryExpression(
+                      Token.PLUS,
+                      new StringLiteralExpression(
+                        '"' + escapeChars(field.name) + '":',
+                        c.declaration.range
+                      ),
+                      new BinaryExpression(
+                        Token.PLUS,
+                        new CallExpression(
+                          new PropertyAccessExpression(
+                            new IdentifierExpression(
+                              "JSON",
+                              false,
+                              c.declaration.range
+                            ),
+                            new IdentifierExpression(
+                              "stringify",
+                              false,
+                              c.declaration.range
+                            ),
+                            c.declaration.range
+                          ),
+                          null,
+                          [
+                            new PropertyAccessExpression(
+                              new ThisExpression(c.declaration.range),
+                              new IdentifierExpression(
+                                field.name,
+                                false,
+                                c.declaration.range
+                              ),
+                              c.declaration.range
+                            ),
+                          ],
+                          c.declaration.range
+                        ),
+                        d,
+                        c.declaration.range
+                      ),
+                      c.declaration.range
+                    ),
+                    c.declaration.range
+                  )
+                )
+              );
+            }
+            i++;
+          }
+          fnBody.statements.push(
+            new ReturnStatement(
+              new BinaryExpression(
+                Token.PLUS,
+                new IdentifierExpression("_str", false, c.declaration.range),
+                new StringLiteralExpression("}", c.declaration.range),
+                c.declaration.range
+              ),
+              c.declaration.range
+            )
+          );
+          let __JSON_Serialize = new FunctionPrototype(
+            "__JSON_Serialize",
+            c,
+            new MethodDeclaration(
+              new IdentifierExpression(
+                "__JSON_Serialize",
+                false,
+                c.declaration.range
+              ),
+              null,
+              CommonFlags.INSTANCE,
+              null,
+              new FunctionTypeNode(
+                [],
+                new NamedTypeNode(
+                  new TypeName(
+                    new IdentifierExpression(
+                      "string",
+                      false,
+                      c.declaration.range
+                    ),
+                    null,
+                    c.declaration.range
+                  ),
+                  null,
+                  false,
+                  c.declaration.range
+                ),
+                null,
+                false,
+                c.declaration.range
+              ),
+              fnBody,
+              c.declaration.range
+            )
+          );
+          c.instanceMembers?.set("__JSON_Serialize", __JSON_Serialize);
+          (c.declaration as ClassDeclaration).members.push(
+            __JSON_Serialize.declaration
+          );
+        }
+      }
+    });
+  }
+}
+

package/transform/src/index.ts

@@ -0,0 +1,98 @@
+import {
+    ClassDeclaration,
+    FieldDeclaration,
+    MethodDeclaration,
+    Source
+} from "assemblyscript/dist/assemblyscript";
+import { ClassDecorator, registerDecorator } from "visitor-as/dist/decorator.js";
+import { getName } from "visitor-as/dist/utils.js";
+import { SimpleParser } from "visitor-as/dist/index.js";
+
+class AsJSONTransform extends ClassDecorator {
+    public currentClass!: ClassDeclaration;
+    public sources: Source[] = [];
+    public encodeStmts = new Map<string, string[]>();
+    public decodeCode = new Map<string, string[]>();
+
+    visitMethodDeclaration(node: MethodDeclaration): void {}
+    visitFieldDeclaration(node: FieldDeclaration): void {
+        const name = getName(node);
+        if (!node.type) {
+            throw new Error(`Field ${name} is missing a type declaration`);
+        }
+
+        const type = getName(node.type);
+
+        const className = this.currentClass!.name.text
+        if (!this.encodeStmts.has(className)) this.encodeStmts.set(className, [])
+        if (!this.decodeCode.has(className)) this.decodeCode.set(className, [])
+        // @ts-ignore
+        this.encodeStmts.get(className).push(
+            `this.__JSON_Serialized += '' + '"' + '${name}' + '"' + ':' + JSON.stringify<${type}>(this.${name}) + ',';`
+        );
+
+        // @ts-ignore
+        this.decodeCode.get(className).push(
+            `${name}: JSON.parse<${type}>(values.get("${name}")),\n`
+        );
+    }
+    visitClassDeclaration(node: ClassDeclaration): void {
+        if (!node.members) {
+            return;
+        }
+
+        this.currentClass = node;
+
+        const name = getName(node);
+
+        this.encodeStmts.delete(name);
+        this.decodeCode.delete(name);
+        this.visit(node.members);
+
+        const serializedProp = `__JSON_Serialized: string = "";`
+
+        let serializeFunc = ``
+
+        if (this.encodeStmts.has(name) && this.encodeStmts.get(name)) {
+            serializeFunc = `
+      __JSON_Serialize(): string {
+        if (!this.__JSON_Serialized) {
+          ${// @ts-ignore
+                this.encodeStmts.get(name).join("\n")};
+          this.__JSON_Serialized = "{" + this.__JSON_Serialized.slice(0, this.__JSON_Serialized.length - 1) + "}";
+        }
+        return this.__JSON_Serialized;
+      }
+      `
+        } else {
+            serializeFunc = `
+      __JSON_Serialize(): string {
+        return "{}";
+      }
+      `
+        }
+
+        const deserializeFunc = `
+    __JSON_Deserialize(values: Map<string, string>): ${name} {
+        return {
+          ${// @ts-ignore
+            this.decodeCode.get(name) ? this.decodeCode.get(name).join("") : ""}
+        }
+    }
+    `;
+        //console.log(serializedProp, serializeFunc, deserializeFunc)
+        const serializedProperty = SimpleParser.parseClassMember(serializedProp, node);
+        node.members.push(serializedProperty);
+
+        const serializeMethod = SimpleParser.parseClassMember(serializeFunc, node);
+        node.members.push(serializeMethod);
+
+        const deserializeMethod = SimpleParser.parseClassMember(deserializeFunc, node);
+        node.members.push(deserializeMethod);
+    }
+    get name(): string {
+        return "json";
+    }
+}
+
+export default registerDecorator(new AsJSONTransform());

package/transform/tsconfig.json

@@ -1,71 +1,70 @@
 {
-    "compilerOptions": {
-      /* Visit https://aka.ms/tsconfig.json to read more about this file */
-  
-      /* Basic Options */
-      // "incremental": true,                         /* Enable incremental compilation */
-      "target": "esnext",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
-      "module": "commonjs",                           /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
-      // "lib": [],                                   /* Specify library files to be included in the compilation. */
-      // "allowJs": true,                             /* Allow javascript files to be compiled. */
-      // "checkJs": true,                             /* Report errors in .js files. */
-      // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
-      "declaration": false,                         /* Generates corresponding '.d.ts' file. */
-      // "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
-      "sourceMap": false,                           /* Generates corresponding '.map' file. */
-      // "outFile": "./",                             /* Concatenate and emit output to single file. */
-      "outDir": "./lib/",                            /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
-      // "composite": true,                           /* Enable project compilation */
-      // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
-      // "removeComments": true,                      /* Do not emit comments to output. */
-      // "noEmit": true,                              /* Do not emit outputs. */
-      // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
-      "downlevelIteration": true,                  /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
-      // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-  
-      /* Strict Type-Checking Options */
-      "strict": true,                                 /* Enable all strict type-checking options. */
-      "noImplicitAny": true,                       /* Raise error on expressions and declarations with an implied 'unknown' type. */
-      "strictNullChecks": true,                    /* Enable strict null checks. */
-      "strictFunctionTypes": true,                 /* Enable strict checking of function types. */
-      "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
-      "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
-      "noImplicitThis": true,                      /* Raise error on 'this' expressions with an implied 'unknown' type. */
-      "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
-  
-      /* Additional Checks */
-      "noUnusedLocals": true,                      /* Report errors on unused locals. */
-      "noUnusedParameters": true,                  /* Report errors on unused parameters. */
-      "noImplicitReturns": true,                   /* Report error when not all code paths in function return a value. */
-      // "noFallthroughCasesInSwitch": true,          /* Report errors for fallthrough cases in switch statement. */
-      "noUncheckedIndexedAccess": true,            /* Include 'undefined' in index signature results */
-      "noPropertyAccessFromIndexSignature": true,  /* Require undeclared properties from index signatures to use element accesses. */
-  
-      /* Module Resolution Options */
-      // "moduleResolution": "node",                  /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
-      // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
-      // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
-      // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
-      // "typeRoots": [],                             /* List of folders to include type definitions from. */
-      // "types": [],                                 /* Type declaration files to be included in compilation. */
-      // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-      "esModuleInterop": true,                        /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
-      // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
-      // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
-  
-      /* Source Map Options */
-      // "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
-      // "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
-      // "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
-      // "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-  
-      /* Experimental Options */
-      // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
-      // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
-  
-      /* Advanced Options */
-      "skipLibCheck": true,                           /* Skip type checking of declaration files. */
-      "forceConsistentCasingInFileNames": true        /* Disallow inconsistently-cased references to the same file. */
-    }
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                         /* Enable incremental compilation */
+    "target": "es6" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */,
+    "module": "es6" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
+    // "lib": [],                                   /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                             /* Allow javascript files to be compiled. */
+    // "checkJs": true,                             /* Report errors in .js files. */
+    // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
+    "declaration": false /* Generates corresponding '.d.ts' file. */,
+    // "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    "sourceMap": false /* Generates corresponding '.map' file. */,
+    // "outFile": "./",                             /* Concatenate and emit output to single file. */
+    "outDir": "./lib/" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
+    // "composite": true,                           /* Enable project compilation */
+    // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
+    // "removeComments": true,                      /* Do not emit comments to output. */
+    // "noEmit": true,                              /* Do not emit outputs. */
+    // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
+    "downlevelIteration": true /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */,
+    // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true /* Enable all strict type-checking options. */,
+    "noImplicitAny": true /* Raise error on expressions and declarations with an implied 'Unknown' type. */,
+    "strictNullChecks": true /* Enable strict null checks. */,
+    "strictFunctionTypes": true /* Enable strict checking of function types. */,
+    "strictBindCallApply": true /* Enable strict 'bind', 'call', and 'apply' methods on functions. */,
+    "strictPropertyInitialization": true /* Enable strict checking of property initialization in classes. */,
+    "noImplicitThis": true /* Raise error on 'this' expressions with an implied 'Unknown' type. */,
+    "alwaysStrict": true /* Parse in strict mode and emit "use strict" for each source file. */,
+
+    /* Additional Checks */
+    "noUnusedLocals": true /* Report errors on unused locals. */,
+    "noUnusedParameters": true /* Report errors on unused parameters. */,
+    "noImplicitReturns": true /* Report error when not all code paths in function return a value. */,
+    // "noFallthroughCasesInSwitch": true,          /* Report errors for fallthrough cases in switch statement. */
+    "noUncheckedIndexedAccess": true /* Include 'undefined' in index signature results */,
+    "noPropertyAccessFromIndexSignature": true /* Require undeclared properties from index signatures to use element accesses. */,
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",                  /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                             /* List of folders to include type definitions from. */
+    // "types": [],                                 /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": false /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
+    // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true /* Skip type checking of declaration files. */,
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */
   }
-  
+}