functionalscript 0.0.295 → 0.0.299

package/LANGUAGE.md

@@ -0,0 +1,208 @@
+# FunctionaScript Programming Language
+
+## 1. Module Ecosystem
+
+FunctionalScript uses [CommonJS](https://en.wikipedia.org/wiki/CommonJS) conventions as a module ecosystem. For example,
+
+```js
+const thirdPartyModule = require('third-party-package/module')
+
+const result = thirdPartyModule.someFunction('hello')
+```
+
+## 2. Packages
+
+FunctionalScript uses a `package.json` file to define a package. This file is compatible with [Node.js `package.json`](https://nodejs.org/en/knowledge/getting-started/npm/what-is-the-file-package-json/).
+The prefered way to refence dependencies is to use a GitHub URL. These dependencies in a `package.json` file could look like this,
+
+```json
+{
+   // ...
+   "dependencies": {
+      "third-party-package": "github:exampleorg/thirdpartypackage"
+   }
+   // ...
+}
+```
+
+**Note:** this repository is also a FunctionalScript package, and it can be used as a library. To install this package, use
+
+```
+npm install -S github:functionalscript/functionalscript
+```
+
+## 3. Module Structure
+
+A module is a file with the `.js` extention. It contains three parts: references to other modules, definitions, and exports. For example
+
+`./first.js`
+```js
+// 1. references
+const math = require('math')
+
+// 2. definitions
+const myConst = 42
+// addition(a)(b) = a + b
+const addition = a => b => a + b
+const add42 = addition(42)
+const _10digitsOfPi = math.calculatePi(10)
+
+// 3. exports
+module.exports = {
+   addition,
+   add42,
+   _10digitsOfPi,
+}
+```
+
+`./second.js`
+```js
+// 1. references
+const first = require('./first.js')
+
+// 2. definitions
+const _42plus7 = first.add42(7)
+
+// 3. exports
+module.exports = {
+   _42plus7,
+}
+```
+
+## 4. References To Other Modules
+
+The format of references is `const ANYNAME = require('PATH_TO_A_MODULE')`. For example,
+
+```js
+const math = require('math')
+const algebra = require('math/algebra')
+const localFile = require('../some-directory/some-file.js')
+```
+
+## 5. Definitions
+
+The format of defintions is `const NAME = EXPRESSION`, where the `EXPRESSION` is a subset of [JavaScript expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators).
+
+```js
+const myConst = 42
+const functionDouble = a => a * 2
+const structure = { name: "John", surname: "Smith" }
+const array = [1, 2, 3]
+const nestedStructure = {
+   address: undefined,
+   serialNumber: "123-45-78",
+   sum: 14 + myConst + functionDouble(4),
+   moreInfo: {
+      name: "Ivan",
+      surname: "Terrible",
+   }
+}
+```
+
+See [Expressions](#7-Expressions).
+
+### 6. Exports
+
+The format of exports is `module.exports = { A_LIST_OF_EXPORTED_DEFINITIONS }`. There should be only one `module.exports` at
+the end of a FunctionalScript file. For example,
+
+```js
+module.exports = {
+   nestedStructure,
+   array,
+   structure,
+}
+```
+
+## 7. Expressions
+
+Expressions could fall under these categories:
+
+- Literals:
+  - Number Literals, e.g. `0`, `3.14`, `4e8`
+  - Boolean Literals: `true` or `false`
+  - A `null` Literal
+  - An `undefined` Literal
+  - String Literals, e.g. `"Hello world!"`
+- Complex Structures
+  - Arrays, e.g. `[2, 5]`
+  - Objects, e.g. `{ a: "Hello", b: "world!" }`
+  - Arrow functions, e.g. `x => x * 2`
+- Operators
+  - Comparison Operators: `===`, `!==`, `>`, `>=`, `<`, `<=`
+  - Arithmetic Operators: `+`, `-`, `*`, `/`, `%`, `**`
+  - Bitwise Operators: `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`
+  - Logical Operators: `&&`, `||`, `!`, `??`
+  - Conditional Operator, e.g. `condition ? val1 : val2`
+  - Template Literals, e.g. `string ${expression}`
+  - `typeof`
+  - Relations Operators: `in`, `instanceof`.
+  - Member Operators: `.`, `[]`.
+
+Note: the `.` member operator has prohibitted property names, such as `constructor` and `push`. To access such properties, it's recommeded to use the [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/getOwnPropertyDescriptor) function.
+
+## 8. Arrow Functions
+
+An arrow function is also known as [a lambda function](https://en.wikipedia.org/wiki/Anonymous_function).
+The format of an arrow function is `ARGUMENT_NAME => FUNCTION_BODY`. An arrow function must have either a single argument or no arguments at all. For example
+
+```js
+x => x * 2
+a => a + 4
+s => `template literal ${s}`
+a => b => a + b // an arrow functions that returns another arrow functions.
+() => 'hello' // an arrow function with no arguments
+```
+
+A function body is either an expression or a block statement. A block statement format is `{ A_LIST_OF_STATEMENTS }`. For example
+
+```js
+// a function with one argument and a block statement
+const f = x => {
+   const a = 2 + x
+   const r = a + 4
+   return r
+}
+```
+
+## 9. Statements
+
+`{ A_LIST_OF_STATEMENTS }` is one or many statements seperated by the newline control character. One of these statements mentioned earlier was [definition](#5-Definitions), also known as a [const](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const) statement. The other statements are described below.
+
+### 9.1. Let
+
+[Let](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let) declares a local mutable alias for immutable objects. For example
+
+```js
+let x = [5]
+// you can assign another immutable object to the alias at any time.
+x = [3, 4]
+//but you can't change the properties of the immutable object.
+x[0] = 3 // < invalid
+//let aliases can not be referenced from another arrow function.
+const f = () => x // < invalid
+```
+
+### 9.2. Return
+
+[Return](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/return)
+
+### 9.3. If...Else
+
+[If...Else](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else)
+
+### 9.4. Switch
+
+[Switch](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch)
+
+### 9.5. Throw
+
+[Throw](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw). FunctionalScript allows to throw exceptions but it doesn't catch them. You should only be using Statement throw in non-recoverable situations. It could be compared to [panic in Rust](https://doc.rust-lang.org/std/macro.panic.html).
+
+### 9.6. While
+
+[While](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/while)
+
+### 9.7. Block
+
+[Block](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block)

package/README.md

@@ -1,228 +1,21 @@
 # FunctionalScript
 
-FunctionalScript is a pure functional programming language and a strict subset of 
-[ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by 
+FunctionalScript is a pure functional programming language and a strict subset of
+[ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by
 
 - [JSON](https://en.wikipedia.org/wiki/JSON) as a subset of JavaScript. JSON is also a subset of FunctionalScript.
 - [asm.JS](https://en.wikipedia.org/wiki/Asm.js)/[WebAssembly](https://en.wikipedia.org/wiki/WebAssembly), as a subset of JavaScript.
 - [TypeScript](https://en.wikipedia.org/wiki/TypeScript), as a superset of JavaScript.
 
+[A brief description of FunctionalScript Programming Language](./LANGUAGE.md).
+
 Create a new FunctionalScript repository on GitHub [here](https://github.com/functionalscript/template/generate).
 
-## 1. Design Principles
+## Design Principles
 
 In FunctionalScript:
 
 - Any module is a valid JavaScript module. No additional build steps are required.
 - Code should not have [side-effects](https://en.wikipedia.org/wiki/Side_effect_(computer_science)). Any JavaScript statement, expression, or function which has a side effect is not allowed in FunctionalScript. There are no exceptions to this rule, such as `unsafe` code which can be found in Rust, C#, and other languages.
-- A module can't depend on non FunctionalScript module. 
+- A module can't depend on non FunctionalScript module.
 - It also has no standard library, only a safe subset of standard JavaScript API can be used without referencing other modules.
-
-## 2. Outlines
-
-### 2.1. Module Ecosystem
-
-FunctionalScript uses [CommonJS](https://en.wikipedia.org/wiki/CommonJS) conventions as a module ecosystem. For example,
-
-```js
-const thirdPartyModule = require('third-party-package/module')
-
-const result = thirdPartyModule.someFunction('hello')
-```
-
-### 2.2. Packages
-
-FunctionalScript uses a `package.json` file to define a package. This file is compatible with [Node.js `package.json`](https://nodejs.org/en/knowledge/getting-started/npm/what-is-the-file-package-json/). 
-The prefered way to refence dependencies is to use a GitHub URL. These dependencies in a `package.json` file could look like this,
-
-```json
-{
-   // ...
-   "dependencies": {
-      "third-party-package": "github:exampleorg/thirdpartypackage"
-   }
-   // ...
-}
-```
-
-**Note:** this repository is also a FunctionalScript package, and it can be used as a library. To install this package, use
-
-```
-npm install -S github:functionalscript/functionalscript
-```
-
-### 2.3. Module Structure
-
-A module is a file with the `.js` extention. It contains three parts: references to other modules, definitions, and exports. For example
-
-`./first.js`
-```js
-// 1. references
-const math = require('math')
-
-// 2. definitions
-const myConst = 42
-// addition(a)(b) = a + b
-const addition = a => b => a + b
-const add42 = addition(42)
-const _10digitsOfPi = math.calculatePi(10)
-
-// 3. exports
-module.exports = {
-   addition,
-   add42,
-   _10digitsOfPi,
-}
-```
-
-`./second.js`
-```js
-// 1. references
-const first = require('./first.js')
-
-// 2. definitions
-const _42plus7 = first.add42(7)
-
-// 3. exports
-module.exports = {
-   _42plus7,
-}
-```
-
-### 2.4. References To Other Modules
-
-The format of references is `const ANYNAME = require('PATH_TO_A_MODULE')`. For example,
-
-```js
-const math = require('math')
-const algebra = require('math/algebra')
-const localFile = require('../some-directory/some-file.js')
-```
-
-### 2.5. Definitions
-
-The format of defintions is `const NAME = EXPRESSION`, where the `EXPRESSION` is a subset of [JavaScript expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators).
-
-```js
-const myConst = 42
-const functionDouble = a => a * 2
-const structure = { name: "John", surname: "Smith" }
-const array = [1, 2, 3]
-const nestedStructure = { 
-   address: undefined, 
-   serialNumber: "123-45-78", 
-   sum: 14 + myConst + functionDouble(4),
-   moreInfo: { 
-      name: "Ivan",
-      surname: "Terrible",
-   } 
-}
-```
-
-See [3. Expressions](#3-Expressions).
-
-### 2.6. Exports
-
-The format of exports is `module.exports = { A_LIST_OF_EXPORTED_DEFINITIONS }`. There should be only one `module.exports` at
-the end of a FunctionalScript file. For example,
-
-```js
-module.exports = {
-   nestedStructure,
-   array,
-   structure,
-}
-```
-
-## 3. Expressions
-
-Expressions could fall under these categories:
-
-- Literals:
-  - Number Literals, e.g. `0`, `3.14`, `4e8`
-  - Boolean Literals: `true` or `false`
-  - A `null` Literal
-  - An `undefined` Literal
-  - String Literals, e.g. `"Hello world!"`
-- Complex Structures
-  - Arrays, e.g. `[2, 5]`
-  - Objects, e.g. `{ a: "Hello", b: "world!" }`
-  - Arrow functions, e.g. `x => x * 2`
-- Operators
-  - Comparison Operators: `===`, `!==`, `>`, `>=`, `<`, `<=`
-  - Arithmetic Operators: `+`, `-`, `*`, `/`, `%`, `**`
-  - Bitwise Operators: `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`
-  - Logical Operators: `&&`, `||`, `!`, `??`
-  - Conditional Operator, e.g. `condition ? val1 : val2`
-  - Template Literals, e.g. `string ${expression}` 
-  - `typeof`
-  - Relations Operators: `in`, `instanceof`.
-  - Member Operators: `.`, `[]`. 
-    
-Note: the `.` member operator has prohibitted property names, such as `constructor` and `push`. To access such properties, it's recommeded to use the [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/getOwnPropertyDescriptor) function.
-
-## 4. Arrow Functions
-
-An arrow function is also known as [a lambda function](https://en.wikipedia.org/wiki/Anonymous_function).
-The format of an arrow function is `ARGUMENT_NAME => FUNCTION_BODY`. An arrow function must have either a single argument or no arguments at all. For example
-
-```js
-x => x * 2
-a => a + 4
-s => `template literal ${s}`
-a => b => a + b // an arrow functions that returns another arrow functions.
-() => 'hello' // an arrow function with no arguments
-```
-
-A function body is either an expression or a block statement. A block statement format is `{ A_LIST_OF_STATEMENTS }`. For example
-
-```js
-// a function with one argument and a block statement
-const f = x => {
-   const a = 2 + x
-   const r = a + 4
-   return r
-}
-```
-
-## 5. Statements
-
-`{ A_LIST_OF_STATEMENTS }` is one or many statements seperated by the newline control character. One of these statements mentioned earlier was [definition](#25-Definitions), also known as a [const](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const) statement. The other statements are described below.
-
-### 5.1 Let 
-
-[Let](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let) declares a local mutable alias for immutable objects. For example
-
-```js
-let x = [5]
-// you can assign another immutable object to the alias at any time.
-x = [3, 4]
-//but you can't change the properties of the immutable object.
-x[0] = 3 // < invalid
-//let aliases can not be referenced from another arrow function.
-const f = () => x // < invalid
-```
-
-### 5.2 Return 
-
-[Return](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/return)
-
-### 5.3 If...Else
-
-[If...Else](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else)
-
-### 5.4 Switch
-
-[Switch](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch)
-
-### 5.5 Throw
-
-[Throw](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw). FunctionalScript allows to throw exceptions but it doesn't catch them. You should only be using Statement throw in non-recoverable situations. It could be compared to [panic in Rust](https://doc.rust-lang.org/std/macro.panic.html).
-
-### 5.6 While
-
-[While](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/while)
-
-### 5.7 Block
-
-[Block](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.295",
+  "version": "0.0.299",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/test.js

@@ -3,6 +3,7 @@ const i = require('./')
 require('./types/list/test')
 require('./types/array/test')
 require('./types/btree/test')
+require('./types/crypto/test')
 require('./json/test')
 require('./types/object/test')
 require('./io/commonjs/test')

package/types/btree/index.js

@@ -48,11 +48,6 @@ const seq = require('../list')
  * @typedef { Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>} Node
  */
 
-/**
- * @template T
- * @typedef { readonly[...Branch5<T>, T, Node<T>] } Branch7
- */
-
 /** @type {<T>(node: Node<T>) => seq.Thunk<T>} */
 const values = node => () => {
     switch (node.length) {
@@ -81,6 +76,11 @@ const values = node => () => {
  * @typedef {readonly[Node<T>]} Branch1
  */
 
+/**
+ * @template T
+ * @typedef { readonly[...Branch5<T>, T, Node<T>] } Branch7
+ */
+
 module.exports = {
     /** @readonly */
     values,

package/types/crypto/index.js

@@ -0,0 +1,192 @@
+/**
+ * @typedef {{
+ *  readonly input: number[]
+ *  readonly length: number
+ * }} HashInput
+ */
+
+/**
+ * @typedef {readonly[number, number, number, number, number, number, number, number]} HashOutput8
+ */
+
+/** @type  {(input: number) => (pos: number) => number} */
+const appendOne = input => pos =>
+{
+    return input | (1 << 31 - pos)
+}
+
+/** @type  {(input: number) => (pos: number) => number} */
+const unsignedMod = a => b =>
+{
+    return (a % b + b) % b
+}
+
+/** @type  {(input: number[]) => (length: number) => readonly number[]} */
+const padding = input => length =>
+{
+    const appendBlockIndex = Math.floor(length / 32)
+    //console.log(appendBlockIndex)
+    const k = unsignedMod(447 - length)(512)
+    //console.log(k)
+    const outputLength = length + k + 65
+    //console.log(outputLength)
+    let o = new Array(outputLength / 32)
+    //console.log(o.length)
+    /** @type {(i: number) => number} */
+    const f = i =>
+        i < appendBlockIndex ?
+            input[i] :
+        i === appendBlockIndex ?
+            (appendBlockIndex >= input.length ? 0x80000000 : appendOne(input[appendBlockIndex])(length % 32)) :
+        i === o.length - 2 ? (length / 4294967296) | 0 :
+        i === o.length - 1 ? length % 4294967296 : 0
+    for(let i = 0; i < o.length; i++)
+    {
+        o[i] = f(i)
+    }
+    return o;
+}
+
+/** @type {(x: number) => (y: number) => (z: number) => number} */
+const ch = x => y => z =>
+{
+    return x & y ^ ~x & z
+}
+
+/** @type {(x: number) => (y: number) => (z: number) => number} */
+const maj = x => y => z =>
+{
+    return x & y ^ x & z ^ y & z
+}
+
+/** @type {(n: number) => (d: number) => number} */
+const rotr = n => d =>
+{
+    return n >>> d | n << (32-d)
+}
+
+/** @type {(n: number) => (d: number) => number} */
+const shr = n => d =>
+{
+    return n >>> d
+}
+
+/** @type {(x: number) => number} */
+const bsig0 = x =>
+{
+    return rotr(x)(2) ^ rotr(x)(13) ^ rotr(x)(22)
+}
+
+/** @type {(x: number) => number} */
+const bsig1 = x =>
+{
+    return rotr(x)(6) ^ rotr(x)(11) ^ rotr(x)(25)
+}
+
+/** @type {(x: number) => number} */
+const ssig0 = x =>
+{
+    return rotr(x)(7) ^ rotr(x)(18) ^ shr(x)(3)
+}
+
+/** @type {(x: number) => number} */
+const ssig1 = x =>
+{
+    return rotr(x)(17) ^ rotr(x)(19) ^ shr(x)(10)
+}
+
+/** @type {(x: number) => number} */
+const mod2pow32 = x =>
+{
+    return x % 4294967296
+}
+
+/** @type {(input: number[]) => (length: number) => HashOutput8} */
+const computeSha256 = input => length =>
+{
+    const padded = padding(input)(length)
+
+    let h0 = 0x6a09e667
+    let h1 = 0xbb67ae85
+    let h2 = 0x3c6ef372
+    let h3 = 0xa54ff53a
+    let h4 = 0x510e527f
+    let h5 = 0x9b05688c
+    let h6 = 0x1f83d9ab
+    let h7 = 0x5be0cd19
+
+    const k = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+    ];
+
+    // /** @type {(a: number) => string} */
+    // const toHexString = x =>
+    // {
+    //     return x >= 0 ? x.toString(16).padStart(8, '0') : (x + 0x100000000).toString(16).padStart(8, '0')
+    // }
+
+    let w = new Array(64)
+    const chunkCount = padded.length / 16
+    for(let i = 0; i < chunkCount; i++)
+    {
+        for(let t = 0; t < 16; t++)
+        {
+            w[t] = padded[t + i * 16]
+        }
+
+        for(let t = 16; t < 64; t++)
+        {
+            w[t] = mod2pow32(ssig1(w[t - 2]) + w[t - 7] + ssig0(w[t-15]) + w[t - 16])
+        }
+
+        //console.log(w.map(toHexString))
+
+        let a = h0
+        let b = h1
+        let c = h2
+        let d = h3
+        let e = h4
+        let f = h5
+        let g = h6
+        let h = h7
+
+        for(let t = 0; t < 64; t++)
+        {
+            let t1 = mod2pow32(h + bsig1(e) + ch(e)(f)(g) + k[t] + w[t])
+            let t2 = mod2pow32(bsig0(a) + maj(a)(b)(c))
+            h = g
+            g = f
+            f = e
+            e = mod2pow32(d + t1)
+            d = c
+            c = b
+            b = a
+            a = mod2pow32(t1 + t2)
+        }
+
+        h0 = mod2pow32(h0 + a)
+        h1 = mod2pow32(h1 + b)
+        h2 = mod2pow32(h2+ c)
+        h3 = mod2pow32(h3 + d)
+        h4 = mod2pow32(h4 + e)
+        h5 = mod2pow32(h5 + f)
+        h6 = mod2pow32(h6 + g)
+        h7 = mod2pow32(h7 + h)
+    }
+
+    return [h0, h1, h2, h3, h4, h5, h6, h7]
+}
+
+module.exports = {
+    /** @readonly */
+    padding,
+    /** @readonly */
+    computeSha256,
+}

package/types/crypto/test.js

@@ -0,0 +1,62 @@
+const _ = require('.')
+const json = require('../../json')
+const { sort } = require('../object')
+
+/** @type {(a: number) => string} */
+const toHexString = x =>
+{
+    return x >= 0 ? x.toString(16).padStart(8, '0') : (x + 0x100000000).toString(16).padStart(8, '0')
+}
+
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a)
+
+// {
+//     const result = _.padding([])(0)
+//     console.log(result.map(toHexString))
+// }
+
+// {
+//     const result = _.padding([0x61626364, 0x65000000])(40)
+//     console.log(result.map(toHexString))
+// }
+
+// {
+//     const result = _.padding([0x11111110])(31)
+//     console.log(result.map(toHexString))
+// }
+
+// {
+//     const result = _.padding([0x11111110])(32)
+//     console.log(result.map(toHexString))
+// }
+
+{
+    const hash = _.computeSha256([])(0)
+    const result = stringify(hash.map(toHexString))
+    if (result !== '["e3b0c442","98fc1c14","9afbf4c8","996fb924","27ae41e4","649b934c","a495991b","7852b855"]') { throw result }
+}
+
+{
+    //[0x68656C6C, 0x6F20776F, 0x726C6400] represents phrase 'hello world'
+    const hash = _.computeSha256([0x68656C6C, 0x6F20776F, 0x726C6400])(88)
+    const result = stringify(hash.map(toHexString))
+    if (result !== '["b94d27b9","934d3e08","a52e52d7","da7dabfa","c484efe3","7a5380ee","9088f7ac","e2efcde9"]') { throw result }
+}
+
+{
+    const input = Array(8).fill(0x31313131)
+    const result = _.computeSha256(input)(256)
+    if (result[0] !== 0x8a83665f) { throw result[0] }
+}
+
+{
+    const input = Array(16).fill(0x31313131)
+    const hash = _.computeSha256(input)(512)
+    const result = stringify(hash.map(toHexString))
+    if (result !== '["3138bb9b","c78df27c","473ecfd1","410f7bd4","5ebac1f5","9cf3ff9c","fe4db77a","ab7aedd3"]') { throw result }
+}
+
+module.exports = {
+
+}