signify-ts 0.1.0

package/src/keri/core/matter.ts

@@ -0,0 +1,252 @@
+import {EmptyMaterialError} from "./kering";
+
+const {intToB64, readInt} = require('./core');
+const Base64 = require('urlsafe-base64');
+import {b, d} from "./core";
+
+
+export class MatterCodex {
+    Ed25519_Seed:         string = 'A'    // Ed25519 256 bit random seed for private key
+    Ed25519N:             string = 'B'    // Ed25519 verification key non-transferable, basic derivation.
+    X25519:               string = 'C'    // X25519 public encryption key, converted from Ed25519 or Ed25519N.
+    Ed25519:              string = 'D'    // Ed25519 verification key basic derivation
+    Blake3_256:           string = 'E'    // Blake3 256 bit digest self-addressing derivation.
+    X25519_Private:       string = 'O'    // X25519 private decryption key converted from Ed25519
+    X25519_Cipher_Seed:   string = 'P'    // X25519 124 char b64 Cipher of 44 char qb64 Seed
+    X25519_Cipher_Salt:   string = '1AAH' // X25519 100 char b64 Cipher of 24 char qb64 Salt
+    Salt_128:             string = '0A'   // 128 bit random salt or 128 bit number (see Huge)
+    Ed25519_Sig:          string = '0B'   // Ed25519 signature.
+}
+
+export const MtrDex = new MatterCodex()
+
+export class Sizage {
+    public hs: number;
+    public ss: number;
+    public ls: number;
+    public fs: number;
+
+    constructor(hs: number, ss: number, fs: number, ls: number) {
+        this.hs = hs;
+        this.ss = ss;
+        this.fs = fs;
+        this.ls = ls;
+    }
+}
+
+export interface MatterArgs {
+    raw?: Uint8Array | undefined
+    code?: string
+    qb64b?: Uint8Array | undefined
+    qb64?: string
+    qb2?: Uint8Array | undefined
+}
+
+export class Matter {
+
+    static Sizes = new Map(Object.entries({
+        'A': new Sizage(1, 0, 44, 0),
+        'B': new Sizage(1, 0, 44, 0),
+        'C': new Sizage(1, 0, 44, 0),
+        'D': new Sizage(1, 0, 44, 0),
+        'E': new Sizage(1, 0, 44, 0),
+        'O': new Sizage(1, 0, 44, 0),
+        'P': new Sizage(1, 0, 124, 0),
+        "0A": new Sizage(2, 0, 24, 0),
+        '0B': new Sizage(2, 0, 88, 0),
+        '1AAH': new Sizage(4, 0, 100, 0),
+    }));
+
+    static Hards = new Map<string, number>([['A', 1], ['B', 1], ['C', 1], ['D', 1], ['E', 1], ['F', 1], ['G', 1],
+        ['H', 1], ['I', 1], ['J', 1], ['K', 1], ['L', 1], ['M', 1], ['N', 1], ['O', 1], ['P', 1], ['Q', 1], ['R', 1],
+        ['S', 1], ['T', 1], ['U', 1], ['V', 1], ['W', 1], ['X', 1], ['Y', 1], ['Z', 1], ['a', 1], ['b', 1], ['c', 1],
+        ['d', 1], ['e', 1], ['f', 1], ['g', 1], ['h', 1], ['i', 1], ['j', 1], ['k', 1], ['l', 1], ['m', 1], ['n', 1],
+        ['o', 1], ['p', 1], ['q', 1], ['r', 1], ['s', 1], ['t', 1], ['u', 1], ['v', 1], ['w', 1], ['x', 1], ['y', 1],
+        ['z', 1], ['0', 2], ['1', 4], ['2', 4], ['3', 4], ['4', 2], ['5', 2], ['6', 2], ['7', 4], ['8', 4], ['9', 4]])
+
+
+    private _code: string = "";
+    private _size: number = -1;
+    private _raw: Uint8Array = new Uint8Array(0);
+
+    constructor({raw, code = MtrDex.Ed25519N, qb64b, qb64, qb2}: MatterArgs) {
+
+        let size = -1
+        if (raw !== undefined) {
+            if (code.length === 0) {
+                throw new Error("Improper initialization need either (raw and code) or qb64b or qb64 or qb2.")
+            }
+
+            // Add support for variable size codes here if needed, this code only works for stable size codes
+            let sizage = Matter.Sizes.get(code)
+            if (sizage!.fs === -1) {  // invalid
+                throw new Error(`Unsupported variable size code=${code}`)
+            }
+
+            let rize = Matter._rawSize(code)
+            raw = raw.slice(0, rize)  // copy only exact size from raw stream
+            if (raw.length != rize) { // forbids shorter
+                throw new Error(`Not enougth raw bytes for code=${code} expected ${rize} got ${raw.length}.`)
+            }
+
+            this._code = code  // hard value part of code
+            this._size = size  // soft value part of code in int
+            this._raw = raw    // crypto ops require bytes not bytearray
+
+        } else if (qb64 !== undefined) {
+            this._exfil(qb64)
+        } else if (qb64b !== undefined) {
+            let qb64 = d(qb64b)
+            this._exfil(qb64)
+        } else if (qb2 !== undefined) {
+            this._bexfil(qb2)
+        } else {
+            throw new EmptyMaterialError("EmptyMaterialError");
+        }
+    }
+
+    get code(): string {
+        return this._code;
+    }
+
+    get size() {
+        return this._size;
+    }
+
+    get raw(): Uint8Array {
+        return this._raw
+    }
+
+    get qb64() {
+        return this._infil();
+    }
+
+    get qb64b() {
+        return b(this.qb64)
+    }
+
+    get transferable(): boolean {
+        return !Array.from([MtrDex.Ed25519N]).includes(this.code)
+    }
+
+    static _rawSize(code: string) {
+        let sizage = this.Sizes.get(code)  // get sizes
+        let cs = sizage!.hs + sizage!.ss  // both hard + soft code size
+        if (sizage!.fs === -1) {
+            throw Error(`Non-fixed raw size code ${code}.`)
+        }
+
+        return (Math.floor((sizage!.fs - cs) * 3 / 4)) - sizage!.ls
+
+    }
+
+    static _leadSize(code: string) {
+        let sizage = this.Sizes.get(code);
+        return sizage!.ls
+    }
+
+    get both() {
+        let sizage = Matter.Sizes.get(this.code);
+        return `${this.code}${intToB64(this.size, sizage!.ls)}`
+    }
+
+
+    private _infil() {
+        let code = this.code;
+        let raw = this.raw;
+
+        let ps = ((3 - (raw.length % 3)) % 3);  // pad size chars or lead size bytes
+        let sizage = Matter.Sizes.get(code);
+
+        if (sizage!.fs === -1) {  // Variable size code, NOT SUPPORTED
+            throw new Error("Variable sized codes not supported... yet");
+        } else {
+            let both = code
+            let cs = both.length
+            if ((cs % 4) != ps - sizage!.ls) {  // adjusted pad given lead bytes
+                throw new Error(`Invalid code=${both} for converted raw pad size=${ps}, ${raw.length}.`);
+            }
+            // prepad, convert, and replace upfront
+            // when fixed and ls != 0 then cs % 4 is zero and ps==ls
+            // otherwise  fixed and ls == 0 then cs % 4 == ps
+            let bytes = new Uint8Array(ps + raw.length);
+            for (let i = 0; i < ps; i++) {
+                bytes[i] = 0;
+            }
+            for (let i = 0; i < raw.length; i++) {
+                let odx = i + ps
+                bytes[odx] = raw[i];
+            }
+
+            return both + Base64.encode(Buffer.from(bytes)).slice(cs % 4)
+        }
+    }
+
+    private _exfil(qb64: string) {
+        if (qb64.length == 0) {
+            throw new Error("Empty Material")
+        }
+
+        let first = qb64[0];
+        if (!Array.from(Matter.Hards.keys()).includes(first)) {
+            throw new Error(`Unexpected code ${first}`)
+        }
+
+        let hs = Matter.Hards.get(first);
+        if (qb64.length < hs!) {
+            throw new Error(`Shortage Error`)
+        }
+
+        let hard = qb64.slice(0, hs);
+        if (!Array.from(Matter.Sizes.keys()).includes(hard)) {
+            throw new Error(`Unsupported code ${hard}`)
+        }
+
+        let sizage = Matter.Sizes.get(hard);
+        let cs = sizage!.hs + sizage!.ss;
+        let size = -1;
+        if (sizage!.fs == -1) { // Variable size code, Not supported
+            throw new Error("Variable size codes not supported yet")
+        } else {
+            size = sizage!.fs
+        }
+
+        if (qb64.length < sizage!.fs) {
+            throw new Error(`Need ${sizage!.fs - qb64.length} more chars.`)
+        }
+
+        qb64 = qb64.slice(0, sizage!.fs)
+        let ps = cs % 4
+        let pbs = 2 * (ps == 0 ? sizage!.ls : ps)
+        let raw
+        if (ps != 0) {
+            let base = new Array(ps + 1).join('A') + qb64.slice(cs);
+            let paw = Base64.decode(base)  // decode base to leave prepadded raw
+            let pi = (readInt(paw.slice(0, ps)))  // prepad as int
+            if (pi & (2 ** pbs - 1)) {  // masked pad bits non-zero
+                throw new Error(`Non zeroed prepad bits = {pi & (2 ** pbs - 1 ):<06b} in {qb64b[cs:cs+1]}.`)
+            }
+            raw = paw.slice(ps)  // strip off ps prepad paw bytes
+        } else {
+            let base = qb64.slice(cs);
+            let paw = Base64.decode(base);
+            let li = readInt(paw.slice(0, sizage!.ls))
+            if (li != 0) {
+                if (li == 1) {
+                    throw new Error(`Non zeroed lead byte = 0x{li:02x}.`)
+                } else {
+                    throw new Error(`Non zeroed lead bytes = 0x{li:04x}`)
+                }
+            }
+            raw = paw.slice(sizage!.ls)
+        }
+
+        this._code = hard  // hard only
+        this._size = size
+        this._raw = Uint8Array.from(raw)  // ensure bytes so immutable and for crypto ops
+    }
+
+    private _bexfil(qb2: Uint8Array) {
+        throw new Error(`qb2 not yet supported: ${qb2}`)
+    }
+}

package/src/keri/core/salter.ts

@@ -0,0 +1,85 @@
+import {Signer} from "./signer";
+
+export {};
+const { Matter, MtrDex } = require('./matter');
+const { EmptyMaterialError } = require('./kering')
+import libsodium  from 'libsodium-wrappers-sumo';
+
+export const enum Tier {
+    low = "low",
+    med = "med",
+    high = "high"
+}
+
+interface SalterArgs {
+    raw?: Uint8Array | undefined
+    code? :string
+    tier?:string
+    qb64b? :Uint8Array | undefined
+    qb64?: string
+    qb2?: Uint8Array | undefined
+}
+export class Salter extends Matter {
+
+    constructor({raw, code = MtrDex.Salt_128, tier=Tier.low, qb64, qb64b, qb2}:SalterArgs) {
+        try {
+            super({raw, code, qb64, qb64b, qb2});
+        } catch (e) {
+            if(e instanceof EmptyMaterialError) {
+                if (code == MtrDex.Salt_128) {
+                    let salt = libsodium.randombytes_buf(libsodium.crypto_pwhash_SALTBYTES);
+                    super({raw: salt, code: code})
+                } else {
+                    throw new Error("invalid code for Salter, only Salt_128 accepted")
+                }
+            } else {
+                throw e;
+            }
+        }
+
+        if (this.code != MtrDex.Salt_128) {
+            throw new Error("invalid code for Salter, only Salt_128 accepted")
+        }
+
+        this.tier = tier !== null ? tier : Tier.low
+    }
+
+    private stretch(size: number = 32, path: string = "", tier: Tier | null = null, temp: boolean = false): Uint8Array {
+        tier = tier == null ? this.tier : tier;
+
+        let opslimit: number, memlimit: number
+
+        if (temp) {
+            opslimit = libsodium.crypto_pwhash_OPSLIMIT_MIN
+            memlimit = libsodium.crypto_pwhash_MEMLIMIT_MIN
+
+        } else {
+            switch (tier) {
+                case Tier.low:
+                    opslimit = libsodium.crypto_pwhash_OPSLIMIT_INTERACTIVE
+                    memlimit = libsodium.crypto_pwhash_MEMLIMIT_INTERACTIVE
+                    break;
+                case Tier.med:
+                    opslimit = libsodium.crypto_pwhash_OPSLIMIT_MODERATE
+                    memlimit = libsodium.crypto_pwhash_MEMLIMIT_MODERATE
+                    break;
+                case Tier.high:
+                    opslimit = libsodium.crypto_pwhash_OPSLIMIT_SENSITIVE
+                    memlimit = libsodium.crypto_pwhash_MEMLIMIT_SENSITIVE
+                    break;
+                default:
+                    throw new Error(`Unsupported security tier = ${tier}.`)
+            }
+        }
+
+        return libsodium.crypto_pwhash(size, path, this.raw, opslimit, memlimit, libsodium.crypto_pwhash_ALG_DEFAULT)
+    }
+
+    signer(code: string=MtrDex.Ed25519_Seed, transferable: boolean=true, path: string = "",
+           tier: Tier | null = null, temp:boolean = false): Signer {
+        let seed = this.stretch(Matter._rawSize(code), path, tier, temp)
+
+        return new Signer({raw: seed, code: code, transferable: transferable})
+    }
+
+}

package/src/keri/core/siger.ts

@@ -0,0 +1,39 @@
+import {IdxSigDex, Indexer, IndexerArgs} from "./indexer";
+import {Verfer} from "./verfer";
+
+/**
+   Siger is subclass of Indexer, indexed signature material,
+    Adds .verfer property which is instance of Verfer that provides
+          associated signature verifier.
+
+    See Indexer for inherited attributes and properties:
+
+    Attributes:
+
+    Properties:
+        .verfer is Verfer object instance
+
+    Methods:
+ **/
+
+export class Siger extends Indexer {
+
+  private _verfer?: Verfer
+  constructor({raw, code, qb64, qb64b, qb2}: IndexerArgs, verfer?: Verfer) {
+    super({raw, code, qb64, qb64b, qb2});
+
+    if (!IdxSigDex.has(this.code)) {
+      throw new Error(`Invalid code = ${this.code} for Siger.`)
+    }
+    this._verfer = verfer
+  }
+
+  get verfer(): Verfer | undefined {
+    return this._verfer;
+  }
+
+  set verfer(verfer: Verfer | undefined) {
+    this._verfer = verfer;
+  }
+
+}

package/src/keri/core/signer.ts

@@ -0,0 +1,112 @@
+import {EmptyMaterialError} from "./kering";
+
+export {};
+import libsodium from 'libsodium-wrappers-sumo';
+import {Matter} from './matter';
+import {MtrDex} from './matter';
+import {Verfer} from "./verfer";
+import {Cigar} from "./cigar";
+import {Siger} from "./siger";
+import {IdrDex} from "./indexer";
+
+
+/**
+ * @description Signer is Matter subclass with method to create signature of serialization
+ * It will use .raw as signing (private) key seed
+ * .code as cipher suite for signing and new property .verfer whose property
+ *  .raw is public key for signing.
+ *  If not provided .verfer is generated from private key seed using .code
+ as cipher suite for creating key-pair.
+ */
+interface SignerArgs {
+    raw?: Uint8Array | undefined
+    code?: string
+    qb64b?: Uint8Array | undefined
+    qb64?: string
+    qb2?: Uint8Array | undefined
+    transferable?: boolean
+}
+
+export class Signer extends Matter {
+    private readonly _sign
+    private readonly _verfer: Verfer
+
+    constructor({raw, code = MtrDex.Ed25519_Seed, qb64, qb64b, qb2, transferable = true}: SignerArgs) {
+        try {
+            super({raw, code, qb64, qb64b, qb2})
+        } catch (e) {
+            if (e instanceof EmptyMaterialError) {
+                if (code == MtrDex.Ed25519_Seed) {
+                    let raw = libsodium.randombytes_buf(libsodium.crypto_sign_SEEDBYTES);
+                    super({raw, code, qb64, qb64b, qb2})
+                } else {
+                    throw new Error(`Unsupported signer code = ${code}.`)
+                }
+            } else {
+                throw e
+            }
+        }
+        let verfer
+        if (this.code == MtrDex.Ed25519_Seed) {
+            this._sign = this._ed25519
+            const keypair = libsodium.crypto_sign_seed_keypair(this.raw)
+            verfer = new Verfer({raw: keypair.publicKey, code: transferable ? MtrDex.Ed25519 : MtrDex.Ed25519N})
+
+        } else {
+            throw new Error(`Unsupported signer code = ${this.code}.`)
+        }
+
+        this._verfer = verfer
+
+    }
+
+
+    /**
+     * @description Property verfer:
+     Returns Verfer instance
+     Assumes ._verfer is correctly assigned
+     */
+    get verfer(): Verfer {
+        return this._verfer;
+    }
+
+    sign(ser: Uint8Array, index: number | null = null, only: boolean = false, ondex: number | undefined = undefined) {
+        return this._sign(ser, this.raw, this.verfer, index, only, ondex)
+    }
+
+    _ed25519(ser: Uint8Array, seed: Uint8Array, verfer: Verfer, index: number | null,
+             only: boolean = false, ondex: number | undefined) {
+
+        let sig = libsodium.crypto_sign_detached(
+            ser,
+            Buffer.concat([seed, verfer.raw]),
+        );
+
+        if (index == null) {
+            return new Cigar({raw: sig, code: MtrDex.Ed25519_Sig}, verfer);
+        } else {
+            let code;
+            if (only) {
+                ondex = undefined
+                if (index <= 63) {
+                    code = IdrDex.Ed25519_Crt_Sig
+                } else {
+                    code = IdrDex.Ed25519_Big_Crt_Sig
+                }
+            } else {
+                if(ondex == undefined) {
+                    ondex = index
+                }
+
+                if (ondex == index && index <= 63) // both same and small
+                    code = IdrDex.Ed25519_Sig  //  use  small both same
+                else  //  otherwise big or both not same so use big both
+                    code = IdrDex.Ed25519_Big_Sig   // use use big both
+
+            }
+
+            return new Siger({raw: sig, code: code, index: index, ondex: ondex}, verfer)
+        }
+
+    }
+}

package/src/keri/core/tsconfig.json

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