functionalscript 0.0.389 → 0.0.392

package/json/tokenizer/module.f.cjs

@@ -1,6 +1,9 @@
 const operator = require('../../types/function/operator/module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
 const range = require('../../types/range/module.f.cjs')
+const { stateScan, flat, concat } = list
+const { contains } = range
+const { fromCharCode } = String
 
 /**
  * @typedef {{
@@ -68,11 +71,11 @@ const letterT = 0x74
 const letterU = 0x75
 const letterZ = 0x7a
 
-const containsDigit = range.contains([digit0, digit9])
-const containsDigitOneNine = range.contains([digit1, digit9])
-const containsSmallAF = range.contains([letterA, letterF])
-const containsCapitalAF = range.contains([capitalLetterA, capitalLetterF])
-const containsSmallLetter = range.contains([letterA, letterZ])
+const containsDigit = contains([digit0, digit9])
+const containsDigitOneNine = contains([digit1, digit9])
+const containsSmallAF = contains([letterA, letterF])
+const containsCapitalAF = contains([capitalLetterA, capitalLetterF])
+const containsSmallLetter = contains([letterA, letterZ])
 
 /**
  * @typedef {|
@@ -124,134 +127,111 @@ const containsSmallLetter = range.contains([letterA, letterZ])
 /** @typedef {number|undefined} CharCodeOrEof */
 
 /** @type {(old: string) => (input: number) => string} */
-const appendChar = old => input => `${old}${String.fromCharCode(input)}`
+const appendChar = old => input => `${old}${fromCharCode(input)}`
 
 /** @type {(state: InitialState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const initialStateOp = initialState => input =>
-{
-    if (containsDigitOneNine(input))
-    {
-        return [undefined, { kind: 'number', value: String.fromCharCode(input), numberKind: 'int'}]
+const initialStateOp = initialState => input => {
+    if (containsDigitOneNine(input)) {
+        return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: 'int' }]
     }
-    if (containsSmallLetter(input))
-    {
-        return [undefined, { kind: 'keyword', value: String.fromCharCode(input)}]
+    if (containsSmallLetter(input)) {
+        return [undefined, { kind: 'keyword', value: fromCharCode(input) }]
     }
-    if (isWhiteSpace(input))
-    {
+    if (isWhiteSpace(input)) {
         return [undefined, initialState]
     }
-    switch(input)
-    {
-        case leftBrace: return [[{kind: '{'}], initialState]
-        case rightBrace: return [[{kind: '}'}], initialState]
-        case colon: return [[{kind: ':'}], initialState]
-        case comma: return [[{kind: ','}], initialState]
-        case leftBracket: return [[{kind: '['}], initialState]
-        case rightBracket: return [[{kind: ']'}], initialState]
-        case quotationMark: return[undefined, {kind: 'string', value: ''}]
-        case digit0: return [undefined, { kind: 'number', value: String.fromCharCode(input), numberKind: '0'}]
-        case signMinus: return [undefined, { kind: 'number', value: String.fromCharCode(input), numberKind: '-'}]
-        default: return [[{kind: 'error', message: 'unexpected character'}], initialState]
+    switch (input) {
+        case leftBrace: return [[{ kind: '{' }], initialState]
+        case rightBrace: return [[{ kind: '}' }], initialState]
+        case colon: return [[{ kind: ':' }], initialState]
+        case comma: return [[{ kind: ',' }], initialState]
+        case leftBracket: return [[{ kind: '[' }], initialState]
+        case rightBracket: return [[{ kind: ']' }], initialState]
+        case quotationMark: return [undefined, { kind: 'string', value: '' }]
+        case digit0: return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: '0' }]
+        case signMinus: return [undefined, { kind: 'number', value: fromCharCode(input), numberKind: '-' }]
+        default: return [[{ kind: 'error', message: 'unexpected character' }], initialState]
     }
 }
 
 /** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const parseNumberStateOp = state => input =>
-{
-    if (input === decimalPoint)
-    {
-        switch (state.numberKind)
-        {
+const parseNumberStateOp = state => input => {
+    if (input === decimalPoint) {
+        switch (state.numberKind) {
             case '0':
-            case 'int': return [undefined, {kind: 'number', value: appendChar(state.value)(input), numberKind: '.'}]
-            default: return tokenizeOp({kind: 'invalidNumber'})(input)
+            case 'int': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: '.' }]
+            default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
-    if (input === digit0)
-    {
-        switch (state.numberKind)
-        {
-            case '0': return tokenizeOp({kind: 'invalidNumber'})(input)
-            case '-': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: '0'}]
-            case '.': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'fractional'}]
+    if (input === digit0) {
+        switch (state.numberKind) {
+            case '0': return tokenizeOp({ kind: 'invalidNumber' })(input)
+            case '-': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: '0' }]
+            case '.': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'fractional' }]
             case 'e':
             case 'e+':
-            case 'e-': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'expDigits'}]
-            default: return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: state.numberKind}]
+            case 'e-': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'expDigits' }]
+            default: return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: state.numberKind }]
         }
     }
-    if (containsDigitOneNine(input))
-    {
-        switch (state.numberKind)
-        {
-            case '0': return tokenizeOp({kind: 'invalidNumber'})(input)
-            case '-': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'int'}]
-            case '.': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'fractional'}]
+    if (containsDigitOneNine(input)) {
+        switch (state.numberKind) {
+            case '0': return tokenizeOp({ kind: 'invalidNumber' })(input)
+            case '-': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'int' }]
+            case '.': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'fractional' }]
             case 'e':
             case 'e+':
-            case 'e-': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'expDigits'}]
-            default: return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: state.numberKind}]
+            case 'e-': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'expDigits' }]
+            default: return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: state.numberKind }]
         }
     }
-    if (input === letterE || input === capitalLetterE)
-    {
-        switch (state.numberKind)
-        {
+    if (input === letterE || input === capitalLetterE) {
+        switch (state.numberKind) {
             case '0':
             case 'int':
-            case 'fractional': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'e'}]
-            default: return tokenizeOp({kind: 'invalidNumber'})(input)
+            case 'fractional': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e' }]
+            default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
-    if (input === signMinus)
-    {
-        switch (state.numberKind)
-        {
-            case 'e': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'e-'}]
-            default: return tokenizeOp({kind: 'invalidNumber'})(input)
+    if (input === signMinus) {
+        switch (state.numberKind) {
+            case 'e': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e-' }]
+            default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
-    if (input === signPlus)
-    {
-        switch (state.numberKind)
-        {
-            case 'e': return [undefined, {kind:'number', value: appendChar(state.value)(input), numberKind: 'e+'}]
-            default: return tokenizeOp({kind: 'invalidNumber'})(input)
+    if (input === signPlus) {
+        switch (state.numberKind) {
+            case 'e': return [undefined, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e+' }]
+            default: return tokenizeOp({ kind: 'invalidNumber' })(input)
         }
     }
-    if (isTerminalForNumber(input))
-    {
-        switch (state.numberKind)
-        {
+    if (isTerminalForNumber(input)) {
+        switch (state.numberKind) {
             case '-':
             case '.':
             case 'e':
             case 'e+':
             case 'e-':
-            {
-                const next = tokenizeOp({kind: 'initial'})(input)
-                return [{first: {kind: 'error', message: 'invalid number'}, tail: next[0]}, next[1]]
-            }
+                {
+                    const next = tokenizeOp({ kind: 'initial' })(input)
+                    return [{ first: { kind: 'error', message: 'invalid number' }, tail: next[0] }, next[1]]
+                }
             default:
-            {
-                const next = tokenizeOp({kind: 'initial'})(input)
-                return [{first: {kind: 'number', value: state.value}, tail: next[0]}, next[1]]
-            }
+                {
+                    const next = tokenizeOp({ kind: 'initial' })(input)
+                    return [{ first: { kind: 'number', value: state.value }, tail: next[0] }, next[1]]
+                }
         }
     }
-    return tokenizeOp({kind: 'invalidNumber'})(input)
+    return tokenizeOp({ kind: 'invalidNumber' })(input)
 }
 
 /** @type {(char: number) => boolean} */
-const isTerminalForNumber = char =>
-{
-    if (isWhiteSpace(char))
-    {
+const isTerminalForNumber = char => {
+    if (isWhiteSpace(char)) {
         return true;
     }
-    switch (char)
-    {
+    switch (char) {
         case quotationMark:
         case comma:
         case leftBrace:
@@ -264,10 +244,8 @@ const isTerminalForNumber = char =>
 }
 
 /** @type {(char: number) => boolean} */
-const isWhiteSpace = char =>
-{
-    switch (char)
-    {
+const isWhiteSpace = char => {
+    switch (char) {
         case horizontalTab:
         case newLine:
         case carriageReturn:
@@ -277,102 +255,88 @@ const isWhiteSpace = char =>
 }
 
 /** @type {(state: InvalidNumberState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const invalidNumberStateOp = state => input =>
-{
-    if (isTerminalForNumber(input))
-    {
-        const next = tokenizeOp({kind: 'initial'})(input)
-        return [{first: {kind: 'error', message: 'invalid number'}, tail: next[0]}, next[1]]
+const invalidNumberStateOp = state => input => {
+    if (isTerminalForNumber(input)) {
+        const next = tokenizeOp({ kind: 'initial' })(input)
+        return [{ first: { kind: 'error', message: 'invalid number' }, tail: next[0] }, next[1]]
     }
-    return [undefined, {kind: 'invalidNumber'}]
+    return [undefined, { kind: 'invalidNumber' }]
 }
 
 /** @type {(state: ParseStringState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const parseStringStateOp = state => input =>
-{
-    switch(input)
-    {
-        case quotationMark: return[[{kind: 'string', value: state.value}], {kind: 'initial'}]
-        case backslash: return [undefined, {kind:'escapeChar', value: state.value}]
-        default: return [undefined, {kind:'string', value: appendChar(state.value)(input)}]
+const parseStringStateOp = state => input => {
+    switch (input) {
+        case quotationMark: return [[{ kind: 'string', value: state.value }], { kind: 'initial' }]
+        case backslash: return [undefined, { kind: 'escapeChar', value: state.value }]
+        default: return [undefined, { kind: 'string', value: appendChar(state.value)(input) }]
     }
 }
 
 /** @type {(state: ParseEscapeCharState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const parseEscapeCharStateOp = state => input =>
-{
-    switch(input)
-    {
+const parseEscapeCharStateOp = state => input => {
+    switch (input) {
         case quotationMark:
         case backslash:
-        case slash: return [undefined, {kind: 'string', value: appendChar(state.value)(input)}]
-        case letterB: return [undefined, {kind: 'string', value: appendChar(state.value)(backspace)}]
-        case letterF: return [undefined, {kind: 'string', value: appendChar(state.value)(formfeed)}]
-        case letterN: return [undefined, {kind: 'string', value: appendChar(state.value)(newLine)}]
-        case letterR: return [undefined, {kind: 'string', value: appendChar(state.value)(carriageReturn)}]
-        case letterT: return [undefined, {kind: 'string', value: appendChar(state.value)(horizontalTab)}]
-        case letterU: return [undefined, {kind: 'unicodeChar', value: state.value, unicode: 0, hexIndex: 0}]
+        case slash: return [undefined, { kind: 'string', value: appendChar(state.value)(input) }]
+        case letterB: return [undefined, { kind: 'string', value: appendChar(state.value)(backspace) }]
+        case letterF: return [undefined, { kind: 'string', value: appendChar(state.value)(formfeed) }]
+        case letterN: return [undefined, { kind: 'string', value: appendChar(state.value)(newLine) }]
+        case letterR: return [undefined, { kind: 'string', value: appendChar(state.value)(carriageReturn) }]
+        case letterT: return [undefined, { kind: 'string', value: appendChar(state.value)(horizontalTab) }]
+        case letterU: return [undefined, { kind: 'unicodeChar', value: state.value, unicode: 0, hexIndex: 0 }]
         default: {
-            const next = tokenizeOp({kind: 'string', value: state.value})(input)
-            return [{first: {kind: 'error', message: 'unescaped character'}, tail: next[0]}, next[1]]
+            const next = tokenizeOp({ kind: 'string', value: state.value })(input)
+            return [{ first: { kind: 'error', message: 'unescaped character' }, tail: next[0] }, next[1]]
         }
     }
 }
 
 /** @type {(hex: number) => number|undefined} */
-const hexDigitToNumber = hex =>
-{
+const hexDigitToNumber = hex => {
     if (containsDigit(hex)) { return hex - digit0 }
     if (containsCapitalAF(hex)) { return hex - capitalLetterA + 10 }
     if (containsSmallAF(hex)) { return hex - letterA + 10 }
 }
 
 /** @type {(state: ParseUnicodeCharState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const parseUnicodeCharStateOp = state => input =>
-{
+const parseUnicodeCharStateOp = state => input => {
     const hexValue = hexDigitToNumber(input)
-    if (hexValue === undefined)
-    {
-        const next = tokenizeOp({kind: 'string', value: state.value})(input)
-        return [{first: {kind: 'error', message: 'invalid hex value'}, tail: next[0]}, next[1]]
+    if (hexValue === undefined) {
+        const next = tokenizeOp({ kind: 'string', value: state.value })(input)
+        return [{ first: { kind: 'error', message: 'invalid hex value' }, tail: next[0] }, next[1]]
     }
     const newUnicode = state.unicode | (hexValue << (3 - state.hexIndex) * 4)
-        return [undefined, state.hexIndex === 3 ?
-            {kind: 'string', value: appendChar(state.value)(newUnicode)} :
-            {kind: 'unicodeChar', value: state.value, unicode: newUnicode, hexIndex: state.hexIndex + 1}]
+    return [undefined, state.hexIndex === 3 ?
+        { kind: 'string', value: appendChar(state.value)(newUnicode) } :
+        { kind: 'unicodeChar', value: state.value, unicode: newUnicode, hexIndex: state.hexIndex + 1 }]
 }
 
 /** @type {(s: string) => JsonToken} */
-const stringToKeywordToken = s =>
-{
-    switch(s)
-    {
-        case 'true': return {kind: 'true'}
-        case 'false': return {kind: 'false'}
-        case 'null': return {kind: 'null'}
-        default: return {kind: 'error', message: 'invalid keyword'}
+const stringToKeywordToken = s => {
+    switch (s) {
+        case 'true': return { kind: 'true' }
+        case 'false': return { kind: 'false' }
+        case 'null': return { kind: 'null' }
+        default: return { kind: 'error', message: 'invalid keyword' }
     }
 }
 
 /** @type {(state: ParseKeywordState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const parseKeyWordStateOp = state => input =>
-{
-    if (containsSmallLetter(input))
-    {
-        return [undefined, {kind: 'keyword', value: appendChar(state.value)(input)}]
+const parseKeyWordStateOp = state => input => {
+    if (containsSmallLetter(input)) {
+        return [undefined, { kind: 'keyword', value: appendChar(state.value)(input) }]
     }
     const keyWordToken = stringToKeywordToken(state.value)
-    const next = tokenizeOp({kind: 'initial'})(input)
-    return [{first: keyWordToken, tail: next[0]}, next[1]]
+    const next = tokenizeOp({ kind: 'initial' })(input)
+    return [{ first: keyWordToken, tail: next[0] }, next[1]]
 }
 
 /** @type {(state: EofState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
-const eofStateOp = state => input => [[{kind: 'error', message: 'eof'}], state]
+const eofStateOp = state => input => [[{ kind: 'error', message: 'eof' }], state]
 
 /** @type {operator.StateScan<number, TokenizerState, list.List<JsonToken>>} */
 const tokenizeCharCodeOp = state => {
-    switch(state.kind)
-    {
+    switch (state.kind) {
         case 'initial': return initialStateOp(state)
         case 'keyword': return parseKeyWordStateOp(state)
         case 'string': return parseStringStateOp(state)
@@ -386,35 +350,35 @@ const tokenizeCharCodeOp = state => {
 
 /** @type {(state: TokenizerState) => readonly[list.List<JsonToken>, TokenizerState]} */
 const tokenizeEofOp = state => {
-    switch(state.kind)
-    {
-        case 'initial': return[undefined, {kind: 'eof'}]
-        case 'keyword': return [[stringToKeywordToken(state.value)], {kind: 'eof'}]
+    switch (state.kind) {
+        case 'initial': return [undefined, { kind: 'eof' }]
+        case 'keyword': return [[stringToKeywordToken(state.value)], { kind: 'eof' }]
         case 'string':
         case 'escapeChar':
-        case 'unicodeChar': return [[{kind: 'error', message: '" are missing'}], {kind: 'eof'}]
-        case 'invalidNumber': return [[{kind: 'error', message: 'invalid number'}], {kind: 'eof'}]
+        case 'unicodeChar': return [[{ kind: 'error', message: '" are missing' }], { kind: 'eof' }]
+        case 'invalidNumber': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'eof' }]
         case 'number':
-            switch (state.numberKind)
-            {
+            switch (state.numberKind) {
                 case '-':
                 case '.':
                 case 'e':
                 case 'e+':
-                case 'e-': return [[{kind: 'error', message: 'invalid number'}], {kind: 'invalidNumber', }]
-                default: return [[{kind: 'number', value: state.value}], {kind: 'eof'}]
+                case 'e-': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'invalidNumber', }]
+                default: return [[{ kind: 'number', value: state.value }], { kind: 'eof' }]
             }
-        case 'eof': return [[{kind: 'error', message: 'eof'}], state]
+        case 'eof': return [[{ kind: 'error', message: 'eof' }], state]
     }
 }
 
 /** @type {operator.StateScan<CharCodeOrEof, TokenizerState, list.List<JsonToken>>} */
 const tokenizeOp = state => input => input === undefined ? tokenizeEofOp(state) : tokenizeCharCodeOp(state)(input)
 
-const initial = list.stateScan(tokenizeOp)({ kind: 'initial' })
+const scanTokenize = stateScan(tokenizeOp)
+
+const initial = scanTokenize({ kind: 'initial' })
 
 /** @type {(input: list.List<number>) => list.List<JsonToken>} */
-const tokenize = input => list.flat(initial(list.concat(/** @type {list.List<CharCodeOrEof>} */(input))([undefined])))
+const tokenize = input => flat(initial(flat([/** @type {list.List<CharCodeOrEof>} */(input), [undefined]])))
 
 module.exports = {
     /** @readonly */

package/nodejs/version/module.f.cjs

@@ -1,5 +1,3 @@
-const pack = require('../../commonjs/package/module.f.cjs')
-
 /** 
  * @typedef {{
  *  readonly execSync: (cmd: string) => Buffer
@@ -22,13 +20,15 @@ const pack = require('../../commonjs/package/module.f.cjs')
  * }} Node
  */
 
+const { stringify, parse } = JSON
+
 /** @type {<T>(node: Node<T>) => T} */
 const version = ({ child_process, fs }) =>
     fs.writeFileSync(
         'package.json',
-        JSON.stringify(
+        stringify(
             {
-                ...JSON.parse(fs.readFileSync('package.json').toString()), 
+                ...parse(fs.readFileSync('package.json').toString()), 
                 version: `0.0.${child_process.execSync('git log --oneline').toString().split('\n').length - 1}` 
             }, 
             null, 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.389",
+  "version": "0.0.392",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/sha2/module.f.cjs

@@ -73,33 +73,6 @@ const smallSigma0 = smallSigma(7)(18)(3)
 
 const smallSigma1 = smallSigma(17)(19)(10)
 
-/** @type {Hash8} */
-const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
-
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-const computeSha256 = input => bitsCount => compute(input)(bitsCount)(init256)
-
-/** @type {Hash8} */
-const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]
-
-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 {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-const computeSha224 = input => bitsCount => compute(input)(bitsCount)(init224)
-
 /** @type {(a: array.Array4<number>) => number} */
 const wi = a => (smallSigma1(a[0]) + a[1] + smallSigma0(a[2]) + a[3]) | 0
 
@@ -166,8 +139,8 @@ const compress = init => data => {
     ]
 }
 
-/** @type {(input: readonly number[]) => (bitsCount: number) => (init: Hash8) => Hash8} */
-const compute = input => bitsCount => init => {
+/** @type {(init: Hash8) => (input: readonly number[]) => (bitsCount: number) => Hash8} */
+const compute = init => input => bitsCount => {
     const { f, length } = padding(input)(bitsCount)
 
     let result = init
@@ -183,6 +156,33 @@ const compute = input => bitsCount => init => {
     return result
 }
 
+/** @type {Hash8} */
+const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
+
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+const computeSha256 = compute(init256)
+
+/** @type {Hash8} */
+const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]
+
+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 {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+const computeSha224 = compute(init224)
+
 module.exports = {
     /** @readonly */
     padding,

package/test.f.cjs

@@ -12,7 +12,7 @@ require('./commonjs/package/dependencies/test.f.cjs')
 require('./commonjs/package/test.f.cjs')
 require('./commonjs/path/test.f.cjs')
 require('./types/function/compare/test.f.cjs')
-require('./types/stringset/test.f.cjs')
+require('./types/string_set/test.f.cjs')
 require('./types/option/test.f.cjs')
 require('./commonjs/build/test.f.cjs')
 require('./types/range/test.f.cjs')

package/text/encoding/module.f.cjs

@@ -55,10 +55,8 @@ const codePointToUtf16 = input =>
     return [input & 0xffff]
 }
 
-/** @type {(input: list.List<number>) => list.List<ByteResult>} */
 const codePointListToUtf8List = flatMap(codePointToUtf8)
 
-/** @type {(input: list.List<i32>) => list.List<u16>} */
 const codePointListToUtf16List = flatMap(codePointToUtf16)
 
 /** @type {operator.StateScan<number, Utf8State, list.List<CodePointResult>>} */

package/text/module.f.cjs

@@ -1,4 +1,5 @@
 const list = require('../types/list/module.f.cjs')
+const { flatMap } = list
 
 /** @typedef {ItemThunk|ItemArray} Block */
 
@@ -15,7 +16,7 @@ const flat = indent => {
     const f = prefix => {
         /** @type {(item: Item) => list.List<string>} */
         const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item)
-        return list.flatMap(g)
+        return flatMap(g)
     }
 
     return f('')

package/types/array/module.f.cjs

@@ -1,4 +1,5 @@
 const option = require('../option/module.f.cjs')
+const { map } = option
 
 /**
  * @template T
@@ -97,7 +98,7 @@ const splitFirst = a => {
     /** @typedef {typeof a[0]} T*/
     /** @type {(_: T) => readonly[T, readonly T[]]} */
     const split = first => [first, uncheckTail(a)]
-    return option.map(split)(a[0])
+    return map(split)(a[0])
 }
 
 /** @type {<T>(_: readonly T[]) => readonly T[]|undefined} */

package/types/btree/find/module.f.cjs

@@ -1,6 +1,7 @@
 const _ = require('../types/module.f.cjs')
 const list = require('../../list/module.f.cjs')
 const cmp = require('../../function/compare/module.f.cjs')
+const { index3, index5 } = cmp
 const array = require('../../array/module.f.cjs')
 
 /**
@@ -62,8 +63,8 @@ const child = item =>
 
 /** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
 const find = c => {
-    const i3 = cmp.index3(c)
-    const i5 = cmp.index5(c)
+    const i3 = index3(c)
+    const i5 = index5(c)
     /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
     /** @type {(prior: Path<T>) => (node: _.Node<T>) => Result<T>} */
     const f = tail => node => {