functionalscript 0.2.4 → 0.2.5

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 0.2.5
+
+- new [crypto/] directory [PR #327](https://github.com/functionalscript/functionalscript/pull/327).
+- simplified HTML [PR #327](https://github.com/functionalscript/functionalscript/pull/327).
+- djs: add undefined and comments [PR #325](https://github.com/functionalscript/functionalscript/pull/325).
+
 ## 0.2.3
 
 - BitVec and documentation update [PR #322](https://github.com/functionalscript/functionalscript/pull/322).

package/README.md

@@ -18,7 +18,7 @@ Learn more about
 - [Purely Functional Programming in JavaScript](https://blog.bitsrc.io/purely-functional-programming-in-javascript-91114b1b2dff?sk=5f7132e56902f38fcf4c6164bfa681ed),
 - [FunctionalScript and I/O](https://medium.com/@sergeyshandar/functionalscript-5cf817345376?sk=30b32189a81d1a2dad16c2244f32328d).
 
-FunctionalScript is distributed under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html#license-text). Let us know if you need another license by sending an [email](mailto:sergey.oss@proton.me).
+This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and distributted under under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html#license-text). Let us know if you need another license by sending an [email](mailto:sergey.oss@proton.me).
 
 ## Vision
 

package/crypto/README.md

@@ -0,0 +1,3 @@
+# Cryptography
+
+The directory contains algorithms and utilities for various cryptographic methods.

package/{prime_field → crypto/prime_field}/module.f.mjs

@@ -1,6 +1,6 @@
 // @ts-self-types="./module.f.d.mts"
-import * as Operator from '../types/function/operator/module.f.mjs'
-import * as bi from '../types/bigint/module.f.mjs'
+import * as Operator from '../../types/function/operator/module.f.mjs'
+import * as bi from '../../types/bigint/module.f.mjs'
 const { scalar_mul } = bi
 
 /** @typedef {Operator.Reduce<bigint>} Reduce */

package/{secp → crypto/secp}/module.f.mjs

@@ -1,7 +1,7 @@
 // @ts-self-types="./module.f.d.mts"
-import * as Operator from '../types/function/operator/module.f.mjs'
+import * as Operator from '../../types/function/operator/module.f.mjs'
 import * as pf from '../prime_field/module.f.mjs'
-import * as bi from '../types/bigint/module.f.mjs'
+import * as bi from '../../types/bigint/module.f.mjs'
 const { scalar_mul } = bi
 const { prime_field, sqrt } = pf
 

package/{sha2 → crypto/sha2}/module.f.mjs

@@ -1,5 +1,5 @@
 // @ts-self-types="./module.f.d.mts"
-import * as arrayT from '../types/array/module.f.mjs'
+import * as array from '../../types/array/module.f.mjs'
 
 /**
  * @typedef {{
@@ -8,9 +8,9 @@ import * as arrayT from '../types/array/module.f.mjs'
  * }} HashInput
  */
 
-/** @typedef {arrayT.Array8<number>} Hash8 */
+/** @typedef {array.Array8<number>} Hash8 */
 
-/** @typedef {arrayT.Array16<number>} Array16 */
+/** @typedef {array.Array16<number>} Array16 */
 
 /** @type {(input: number) => (pos: number) => number} */
 const appendOneWithZeros = input => pos => (input >> pos << pos) | (1 << pos)
@@ -74,7 +74,7 @@ const smallSigma0 = smallSigma(7)(18)(3)
 
 const smallSigma1 = smallSigma(17)(19)(10)
 
-/** @type {(a: arrayT.Array4<number>) => number} */
+/** @type {(a: array.Array4<number>) => number} */
 const wi = ([a0, a1, a2, a3]) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) | 0
 
 /** @type {(w: Array16) => Array16} */

package/{sha2 → crypto/sha2}/test.f.mjs

@@ -1,6 +1,6 @@
 import * as _ from './module.f.mjs'
-import * as json from '../json/module.f.mjs'
-import * as o from '../types/object/module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
 
 /** @type {(a: number) => number} */

package/djs/module.f.mjs

@@ -21,10 +21,12 @@ const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize,
 
 /** @typedef {readonly Unknown[]} Array */
 
-/** @typedef {Object|boolean|string|number|null|Array|bigint} Unknown */
+/** @typedef {Object|boolean|string|number|null|Array|bigint|undefined} Unknown */
 
 const colon = [':']
 
+const undefinedSerialize = ['undefined']
+
 /** @typedef {O.Entry<Unknown>} Entry*/
 
 /** @typedef {(list.List<Entry>)} Entries */
@@ -55,6 +57,7 @@ export const serialize = sort => {
             case 'bigint': { return [bigintSerialize(value)] }
             default: {
                 if (value === null) { return nullSerialize }
+                if (value === undefined) { return undefinedSerialize }
                 if (value instanceof Array) { return arraySerialize(value) }
                 return objectSerialize(value)
             }

package/djs/parser/module.f.mjs

@@ -12,7 +12,7 @@ const { fromMap } = o
 
 /** @typedef {[readonly string[], readonly DjsConst[]] } DjsModule */
 
-/** @typedef {boolean|string|number|null|bigint|DjsModuleRef|DjsArray|DjsObject} DjsConst */
+/** @typedef {boolean|string|number|null|bigint|undefined|DjsModuleRef|DjsArray|DjsObject} DjsConst */
 
 /** @typedef {['aref' | 'cref', number]} DjsModuleRef */
 
@@ -113,7 +113,9 @@ const parseInitialOp = token => state => {
     switch (token.kind)
     {
         case 'ws':
-        case 'nl': return state
+        case 'nl':
+        case '//':
+        case '/*': return state
         case 'id': {
             switch (token.value) {
                 case 'import': return { ... state, state: 'import' }
@@ -128,7 +130,9 @@ const parseInitialOp = token => state => {
 /** @type {(token: tokenizerT.DjsToken) => (state: NewLineRequiredState) => ParserState}} */
 const parseNewLineRequiredOp = token => state => {
     switch (token.kind) {
-        case 'ws': return state
+        case 'ws': 
+        case '//':
+        case '/*': return state
         case 'nl': return { ... state, state: '' }
         default: return { state: 'error', message: 'unexpected token' }
     }
@@ -138,7 +142,9 @@ const parseNewLineRequiredOp = token => state => {
 const parseExportOp = token => state => {
     switch (token.kind) {
         case 'ws':
-        case 'nl': return state
+        case 'nl':
+        case '//':
+        case '/*': return state
         case 'id': {
             if (token.value === 'default') return { ... state, state: 'exportValue', valueState: '', top: null, stack: null }
         }
@@ -146,11 +152,24 @@ const parseExportOp = token => state => {
     return { state: 'error', message: 'unexpected token' }
 }
 
+/** @type {(token: tokenizerT.DjsToken) => (state: ResultState) => ParserState}} */
+const parseResultOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state
+        default: return { state: 'error', message: 'unexpected token' }
+    }
+}
+
 /** @type {(token: tokenizerT.DjsToken) => (state: ConstState) => ParserState}} */
 const parseConstOp = token => state => {
     switch (token.kind) {
         case 'ws':
-        case 'nl': return state
+        case 'nl':
+        case '//':
+        case '/*': return state
         case 'id': {
             if (map.at(token.value)(state.module.refs) !== null)
                 return { state: 'error', message: 'duplicate id' }
@@ -167,7 +186,9 @@ const parseConstOp = token => state => {
 const parseConstNameOp = token => state => {
     switch (token.kind) {
         case 'ws':
-        case 'nl': return state
+        case 'nl':
+        case '//':
+        case '/*': return state
         case '=': return { ... state, state: 'constValue', valueState: '', top: null, stack: null }
         default: return { state: 'error', message: 'unexpected token' }
     }
@@ -177,7 +198,9 @@ const parseConstNameOp = token => state => {
 const parseImportOp = token => state => {
     switch (token.kind) {
         case 'ws':
-        case 'nl': return state
+        case 'nl':
+        case '//':
+        case '/*': return state
         case 'id': {
             if (map.at(token.value)(state.module.refs) !== null)
                 return { state: 'error', message: 'duplicate id' }
@@ -194,7 +217,9 @@ const parseImportOp = token => state => {
 const parseImportNameOp = token => state => {
     switch (token.kind) {
         case 'ws':
-        case 'nl': return state
+        case 'nl':
+        case '//':
+        case '/*': return state
         case 'id': {
             if (token.value === 'from') return { ... state, state: 'import+from' }
         }
@@ -206,7 +231,9 @@ const parseImportNameOp = token => state => {
 const parseImportFromOp = token => state => {
     switch (token.kind) {
         case 'ws':
-        case 'nl': return state
+        case 'nl':
+        case '//':
+        case '/*': return state
         case 'string': {
             const modules = list.concat(state.module.modules)([token.value])
             return { ... state, state: 'nl', module: { ...state.module, modules: modules } }
@@ -295,6 +322,7 @@ const tokenToValue = token => {
         case 'number': return parseFloat(token.value)
         case 'string': return token.value
         case 'bigint': return token.value
+        case 'undefined': return undefined
         default: return null
     }
 }
@@ -307,7 +335,8 @@ const isValueToken = token => {
         case 'true':
         case 'number':
         case 'string':
-        case 'bigint': return true
+        case 'bigint':
+        case 'undefined': return true
         default: return false
     }
 }
@@ -315,70 +344,118 @@ const isValueToken = token => {
 /** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseValueOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
-    if (token.kind === 'id') { return pushRef(state)(token.value) }
-    if (token.kind === '[') { return startArray(state) }
-    if (token.kind === '{') { return startObject(state) }
-    if (token.kind === 'ws') { return state }
-    return { state: 'error', message: 'unexpected token' }
+    switch (token.kind)
+    {
+        case 'id': return pushRef(state)(token.value)
+        case '[': return startArray(state)
+        case '{': return startObject(state)
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state
+        default: return { state: 'error', message: 'unexpected token' }
+    }
 }
 
 /** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseArrayStartOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
-    if (token.kind === 'id') { return pushRef(state)(token.value) }
-    if (token.kind === '[') { return startArray(state) }
-    if (token.kind === ']') { return endArray(state) }
-    if (token.kind === '{') { return startObject(state) }
-    if (token.kind === 'ws') { return state }
-    return { state: 'error', message: 'unexpected token' }
+    switch (token.kind)
+    {
+        case 'id': return pushRef(state)(token.value)
+        case '[': return startArray(state)
+        case ']': return endArray(state)
+        case '{': return startObject(state)
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state
+        default: return { state: 'error', message: 'unexpected token' }
+    }
 }
 
 /** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseArrayValueOp = token => state => {
-    if (token.kind === ']') { return endArray(state) }
-    if (token.kind === ',') { return { ... state, valueState: '[,', top: state.top, stack: state.stack } }
-    if (token.kind === 'ws') { return state }
-    return { state: 'error', message: 'unexpected token' }
+    switch (token.kind)
+    {
+        case ']': return endArray(state)
+        case ',': return { ... state, valueState: '[,', top: state.top, stack: state.stack }
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state
+        default: return { state: 'error', message: 'unexpected token' }
+    }
 }
 
 /** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseObjectStartOp = token => state => {
-    if (token.kind === 'string') { return pushKey(state)(token.value) }
-    if (token.kind === '}') { return endObject(state) }
-    if (token.kind === 'ws') { return state }
-    return { state: 'error', message: 'unexpected token' }
+    switch (token.kind)
+    {
+        case 'string': return pushKey(state)(token.value) 
+        case '}': return endObject(state)
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state
+        default: return { state: 'error', message: 'unexpected token' }
+    }
 }
 
 /** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseObjectKeyOp = token => state => {
-    if (token.kind === ':') { return { ... state, valueState: '{:', top: state.top, stack: state.stack } }
-    if (token.kind === 'ws') { return state }
-    return { state: 'error', message: 'unexpected token' }
+    switch (token.kind)
+    {
+        case ':': return { ... state, valueState: '{:', top: state.top, stack: state.stack }
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state
+        default: return { state: 'error', message: 'unexpected token' }
+    }
 }
 
 /** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseObjectColonOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
-    if (token.kind === 'id') { return pushRef(state)(token.value) }
-    if (token.kind === '[') { return startArray(state) }
-    if (token.kind === '{') { return startObject(state) }
-    if (token.kind === 'ws') { return state }
-    return { state: 'error', message: 'unexpected token' }
+    switch (token.kind)
+    {
+        case 'id': return pushRef(state)(token.value)
+        case '[': return startArray(state)
+        case '{': return startObject(state)
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state
+        default: return { state: 'error', message: 'unexpected token' }
+    }
 }
 
 /** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseObjectNextOp = token => state => {
-    if (token.kind === '}') { return endObject(state) }
-    if (token.kind === ',') { return { ... state, valueState: '{,', top: state.top, stack: state.stack } }
-    if (token.kind === 'ws') { return state }
-    return { state: 'error', message: 'unexpected token' }
+    switch (token.kind)
+    {
+        case '}': return endObject(state)
+        case ',': return { ... state, valueState: '{,', top: state.top, stack: state.stack }
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state
+        default: return { state: 'error', message: 'unexpected token' }
+    }
 }
 
 /** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
 const parseObjectCommaOp = token => state => {
-    if (token.kind === 'string') { return pushKey(state)(token.value) }
-    if (token.kind === 'ws') { return state }
-    return { state: 'error', message: 'unexpected token' }
+    switch (token.kind)
+    {
+        case 'string': return pushKey(state)(token.value)
+        case 'ws':
+        case 'nl':
+        case '//':
+        case '/*': return state
+        default: return { state: 'error', message: 'unexpected token' }
+    }
 }
 
 /** @type {Operator.Fold<tokenizerT.DjsToken, ParserState>} */
@@ -392,7 +469,7 @@ const foldOp = token => state => {
         case 'const': return parseConstOp(token)(state)
         case 'const+name': return parseConstNameOp(token)(state)
         case 'export': return parseExportOp(token)(state)
-        case 'result': return { state: 'error', message: 'unexpected token' }
+        case 'result': return parseResultOp(token)(state)
         case 'error': return { state: 'error', message: state.message }
         case 'constValue':
         case 'exportValue':

package/djs/parser/test.f.mjs

@@ -32,6 +32,12 @@ export default {
             const result = stringify(obj)
             if (result !== '["ok",[[],[false]]]') { throw result }
         },
+        () => {
+            const tokenList = tokenizeString('export default undefined')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",[[],[undefined]]]') { throw result }
+        },
         () => {
             const tokenList = tokenizeString('export default 0.1')
             const obj = parser.parse(tokenList)
@@ -87,10 +93,10 @@ export default {
             if (result !== '["ok",[[],[["array",[{}]]]]]') { throw result }
         },
         () => {
-            const tokenList = tokenizeString('export default {"a":true,"b":false,"c":null}')
+            const tokenList = tokenizeString('export default {"a":true,"b":false,"c":null,"d":undefined}')
             const obj = parser.parse(tokenList)
             const result = stringify(obj)
-            if (result !== '["ok",[[],[{"a":true,"b":false,"c":null}]]]') { throw result }
+            if (result !== '["ok",[[],[{"a":true,"b":false,"c":null,"d":undefined}]]]') { throw result }
         },
         () => {
             const tokenList = tokenizeString('export default {"a":{"b":{"c":["d"]}}}')
@@ -259,13 +265,25 @@ export default {
     ],
     validWhiteSpaces:[
         () => {
-            const tokenList = tokenizeString('export default [ 0 , 1 , 2 ]')
+            const tokenList = tokenizeString(' export default [ 0 , 1 , 2 ] ')
             const obj = parser.parse(tokenList)
             const result = stringify(obj)
             if (result !== '["ok",[[],[["array",[0,1,2]]]]]') { throw result }
         },
         () => {
-            const tokenList = tokenizeString('export default { "a" : 0 , "b" : 1 }')
+            const tokenList = tokenizeString(' export default { "a" : 0 , "b" : 1 } ')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",[[],[{"a":0,"b":1}]]]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('\nexport\ndefault\n[\n0\n,\n1\n,\n2\n]\n')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",[[],[["array",[0,1,2]]]]]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('\rexport\rdefault\r{\r"a"\r:\r0\r,\r"b"\r:\r1\r}\r')
             const obj = parser.parse(tokenList)
             const result = stringify(obj)
             if (result !== '["ok",[[],[{"a":0,"b":1}]]]') { throw result }
@@ -409,4 +427,12 @@ export default {
             if (result !== '["error","duplicate id"]') { throw result }
         },
     ],
+    comments: [
+        () => {
+            const tokenList = tokenizeString('export //comment \n default /* comment */ null //comment')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",[[],[null]]]') { throw result }
+        },
+    ]
 }

package/djs/tokenizer/module.f.mjs

@@ -9,7 +9,7 @@ import * as jsTokenizer from '../../js/tokenizer/module.f.mjs'
 
 /**
  * @typedef {|
-* {readonly kind: 'true' | 'false' | 'null'} |
+* {readonly kind: 'true' | 'false' | 'null' | 'undefined'} |
 * {readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=' } |
 * jsTokenizer.StringToken |
 * jsTokenizer.NumberToken |
@@ -17,7 +17,8 @@ import * as jsTokenizer from '../../js/tokenizer/module.f.mjs'
 * jsTokenizer.IdToken |
 * jsTokenizer.BigIntToken |
 * jsTokenizer.WhitespaceToken |
-* jsTokenizer.NewLineToken
+* jsTokenizer.NewLineToken |
+* jsTokenizer.CommentToken
 * } DjsToken
 */
 
@@ -55,6 +56,9 @@ const mapToken = input =>
         case 'number':
         case 'ws':
         case 'nl':
+        case 'undefined':
+        case '//':
+        case '/*':
         case 'error': return [input]
         default: return jsTokenizer.isKeywordToken(input) ? [{ kind: 'id', value: input.kind }] : [{ kind: 'error', message: 'invalid token' }]
     }

package/djs/tokenizer/test.f.mjs

@@ -321,9 +321,43 @@ export default {
             const result = stringify(tokenizeString('null'))
             if (result !== '[{"kind":"null"}]') { throw result }
         },
+        () => {
+            const result = stringify(tokenizeString('undefined'))
+            if (result !== '[{"kind":"undefined"}]') { throw result }
+        },
         () => {
             const result = stringify(tokenizeString('[null]'))
             if (result !== '[{"kind":"["},{"kind":"null"},{"kind":"]"}]') { throw result }
         },
+    ],
+    comments: [
+        () => {
+            const result = stringify(tokenizeString('//singleline comment'))
+            if (result !== '[{"kind":"//","value":"singleline comment"}]') { throw result }
+        },
+        () => {
+            const result = stringify(tokenizeString('true//singleline comment\nfalse'))
+            if (result !== '[{"kind":"true"},{"kind":"//","value":"singleline comment"},{"kind":"nl"},{"kind":"false"}]') { throw result }
+        },
+        () => {
+            const result = stringify(tokenizeString('/* multiline comment */'))
+            if (result !== '[{"kind":"/*","value":" multiline comment "}]') { throw result }
+        },
+        () => {
+            const result = stringify(tokenizeString('/* multiline comment *'))
+            if (result !== '[{"kind":"error","message":"*/ expected"}]') { throw result }
+        },
+        () => {
+            const result = stringify(tokenizeString('/* multiline comment '))
+            if (result !== '[{"kind":"error","message":"*/ expected"}]') { throw result }
+        },
+        () => {
+            const result = stringify(tokenizeString('/* multiline comment \n * **/'))
+            if (result !== '[{"kind":"/*","value":" multiline comment \\n * *"},{"kind":"nl"}]') { throw result }
+        },
+        () => {
+            const result = stringify(tokenizeString('/* multiline comment *\n * **/'))
+            if (result !== '[{"kind":"/*","value":" multiline comment *\\n * *"},{"kind":"nl"}]') { throw result }
+        },
     ]
 }

package/html/module.f.mjs

@@ -14,7 +14,7 @@ const { entries } = Object
 /** @typedef {string} Tag */
 
 // https://developer.mozilla.org/en-US/docs/Glossary/Void_element
-const voidTagList = [
+const voidTagList = /** @type {const} */([
     'area',
     'base',
     'br',
@@ -29,20 +29,20 @@ const voidTagList = [
     'source',
     'track',
     'wbr',
-]
+])
 
-/** @type {(tag: string) => boolean} */
-const isVoid = tag => voidTagList.includes(tag)
+/** @typedef {typeof voidTagList} VoidTagList */
 
-/** @typedef {readonly[Tag]} Element1*/
+/** @typedef {keyof voidTagList} VoidTag */
 
-/** @typedef {readonly[Tag, Attributes]} Element2A */
+/** @type {(tag: string) => boolean} */
+const isVoid = tag => voidTagList.includes(/** @type {any} */(tag))
 
-/** @typedef {readonly[Tag, readonly Node[]]} Element2N */
+/** @typedef {readonly[Tag, ...Node[]]} Element1*/
 
-/** @typedef {readonly[Tag, Attributes, Nodes]} Element3*/
+/** @typedef {readonly[Tag, Attributes, ...Node[]]} Element2 */
 
-/** @typedef {Element1 | Element2A | Element2N | Element3} Element */
+/** @typedef {Element1 | Element2 } Element */
 
 /**
  * @typedef {{
@@ -50,7 +50,7 @@ const isVoid = tag => voidTagList.includes(tag)
  * }} Attributes
  */
 
-/** @typedef {list.List<Node>} Nodes */
+// /** @typedef {list.List<Node>} Nodes */
 
 /** @typedef {Element | string} Node */
 
@@ -82,34 +82,19 @@ const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"
 /** @type {(a: Attributes) => list.List<string>} */
 const attributes = compose(entries)(flatMap(attribute))
 
-const open = (/** @type {Element2A} */[tag, a]) => flat([[`<`, tag], attributes(a), [`>`]])
-
-const close = (/** @type {string}*/tag) => ['</', tag, '>']
+/** @type {(t: string) => (a: Attributes) => list.List<string>} */
+const open = t => a => flat([[`<`, t], attributes(a), [`>`]])
 
-/** @type {(_: Element3) => list.List<string>} */
-const element3 = ([tag, a, ns]) =>
-    flat([open([tag, a]), nodes(ns), close(tag)])
-
-/** @type {(_: Element2A) => list.List<string>} */
-const element2a = e => {
-    const [tag] = e
-    return flat([open(e), isVoid(tag) ? [] : close(tag)])
+/** @type {(t: string) => (an: readonly[Attributes, readonly Node[]]) => list.List<string>} */
+const element3 = t => ([a, n]) => {
+    const o = flat([[`<`, t], attributes(a), [`>`]])
+    return isVoid(t) ? o : flat([o, nodes(n), ['</', t, '>']])
 }
 
 /** @type {(element: Element) => list.List<string>} */
 export const element = e => {
-    switch (e.length) {
-        case 1: { return element2a([e[0], {}]) }
-        case 2: {
-            const [tag, a] = e
-            return a instanceof Array ?
-                element3([tag, {}, a]) :
-                element2a([tag, a])
-        }
-        default: {
-            return element3(e)
-        }
-    }
+    const [t, a, ...n] = e
+    return element3(t)(a === undefined ? [{}, []]: typeof a === 'object' && !(a instanceof Array) ? [a, n] : [{}, [a, ...n]])
 }
 
 export const html = compose(element)(listConcat(['<!DOCTYPE html>']))