functionalscript 0.7.0 → 0.8.1

package/djs/serializer/test.f.js

@@ -1,8 +1,7 @@
 import { countRefs, stringify, stringifyAsTree } from "./module.f.js";
-import * as list from "../../types/object/module.f.js";
-const { sort } = list;
+import { sort } from "../../types/object/module.f.js";
 import { identity } from "../../types/function/module.f.js";
-import * as json from "../../json/module.f.js";
+import { setProperty } from "../../json/module.f.js";
 export default {
     stringify: [
         {
@@ -83,14 +82,14 @@ export default {
     stringifyAsTree: [
         {
             sort: () => {
-                const r = json.setProperty("Hello")(['a'])({});
+                const r = setProperty("Hello")(['a'])({});
                 const x = stringifyAsTree(sort)(r);
                 if (x !== '{"a":"Hello"}') {
                     throw x;
                 }
             },
             identity: () => {
-                const x = stringifyAsTree(identity)(json.setProperty("Hello")(['a'])({}));
+                const x = stringifyAsTree(identity)(setProperty("Hello")(['a'])({}));
                 if (x !== '{"a":"Hello"}') {
                     throw x;
                 }
@@ -98,13 +97,13 @@ export default {
         },
         {
             sort: () => {
-                const x = stringifyAsTree(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                const x = stringifyAsTree(sort)(setProperty("Hello")(['a'])({ c: [], b: 12 }));
                 if (x !== '{"a":"Hello","b":12,"c":[]}') {
                     throw x;
                 }
             },
             identity: () => {
-                const x = stringifyAsTree(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                const x = stringifyAsTree(identity)(setProperty("Hello")(['a'])({ c: [], b: 12 }));
                 if (x !== '{"c":[],"b":12,"a":"Hello"}') {
                     throw x;
                 }
@@ -113,7 +112,7 @@ export default {
         {
             sort: () => {
                 const _0 = { a: { y: [24] }, c: [], b: 12 };
-                const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
+                const _1 = setProperty("Hello")(['a', 'x'])(_0);
                 const _2 = stringifyAsTree(sort)(_1);
                 if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') {
                     throw _2;
@@ -121,7 +120,7 @@ export default {
             },
             identity: () => {
                 const _0 = { a: { y: [24] }, c: [], b: 12 };
-                const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
+                const _1 = setProperty("Hello")(['a', 'x'])(_0);
                 const _2 = stringifyAsTree(identity)(_1);
                 if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') {
                     throw _2;

package/djs/tokenizer/module.f.d.ts

@@ -1,4 +1,4 @@
-import * as list from '../../types/list/module.f.ts';
+import { type List } from '../../types/list/module.f.ts';
 import * as jsTokenizer from '../../js/tokenizer/module.f.ts';
 export type DjsToken = {
     readonly kind: 'true' | 'false' | 'null' | 'undefined';
@@ -9,4 +9,4 @@ export type DjsTokenWithMetadata = {
     readonly token: DjsToken;
     readonly metadata: jsTokenizer.TokenMetadata;
 };
-export declare const tokenize: (input: list.List<number>) => (path: string) => list.List<DjsTokenWithMetadata>;
+export declare const tokenize: (input: List<number>) => (path: string) => List<DjsTokenWithMetadata>;

package/djs/tokenizer/module.f.js

@@ -1,7 +1,5 @@
-import * as list from "../../types/list/module.f.js";
-const { empty, flat, stateScan } = list;
-import * as bf from "../../types/bigfloat/module.f.js";
-const { multiply } = bf;
+import { empty, flat, map, stateScan } from "../../types/list/module.f.js";
+import { multiply } from "../../types/bigfloat/module.f.js";
 import * as jsTokenizer from "../../js/tokenizer/module.f.js";
 const mapToken = input => {
     switch (input.kind) {
@@ -55,7 +53,7 @@ const scanToken = state => input => {
 const mapTokenWithMetadata = metadata => token => { return { token, metadata }; };
 const scanTokenWithMetadata = state => (input) => {
     const [djsTokens, newState] = scanToken(state)(input.token);
-    const djsTokensWithMetadata = list.map(mapTokenWithMetadata(input.metadata))(djsTokens);
+    const djsTokensWithMetadata = map(mapTokenWithMetadata(input.metadata))(djsTokens);
     return [djsTokensWithMetadata, newState];
 };
 export const tokenize = input => path => {

package/djs/tokenizer/test.f.js

@@ -1,13 +1,11 @@
-import * as tokenizer from "./module.f.js";
-import * as list from "../../types/list/module.f.js";
-const { toArray } = list;
-import * as serializer from "../serializer/module.f.js";
-import * as o from "../../types/object/module.f.js";
-const { sort } = o;
-import * as encoding from "../../text/utf16/module.f.js";
-const tokenizeString = s => toArray(list.map(withoutMetada)(tokenizer.tokenize(encoding.stringToList(s))('')));
-const tokenizeStringWithMetadata = s => toArray(tokenizer.tokenize(encoding.stringToList(s))(''));
-const stringify = serializer.stringifyAsTree(sort);
+import { tokenize } from "./module.f.js";
+import { map, toArray } from "../../types/list/module.f.js";
+import { stringifyAsTree } from "../serializer/module.f.js";
+import { sort } from "../../types/object/module.f.js";
+import { stringToList } from "../../text/utf16/module.f.js";
+const tokenizeString = s => toArray(map(withoutMetada)(tokenize(stringToList(s))('')));
+const tokenizeStringWithMetadata = s => toArray(tokenize(stringToList(s))(''));
+const stringify = stringifyAsTree(sort);
 const withoutMetada = tokenWithMetada => { return tokenWithMetada.token; };
 export default {
     djs: [

package/djs/transpiler/module.f.d.ts

@@ -1,4 +1,4 @@
-import type * as djs from '../module.f.ts';
+import { type Unknown } from '../module.f.ts';
 import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
@@ -11,6 +11,6 @@ export type ParseContext = {
     readonly error: ParseError | null;
 };
 export type djsResult = {
-    djs: djs.Unknown;
+    djs: Unknown;
 };
-export declare const transpile: (fs: Fs) => (path: string) => Result<djs.Unknown, ParseError>;
+export declare const transpile: (fs: Fs) => (path: string) => Result<Unknown, ParseError>;

package/djs/transpiler/module.f.js

@@ -1,5 +1,7 @@
+import {} from "../module.f.js";
 import { error, ok } from "../../types/result/module.f.js";
 import { fold, drop, map as listMap, toArray, includes } from "../../types/list/module.f.js";
+import {} from "../../types/function/operator/module.f.js";
 import { tokenize } from "../tokenizer/module.f.js";
 import { setReplace, at } from "../../types/ordered_map/module.f.js";
 import { stringToList } from "../../text/utf16/module.f.js";

package/fsc/bnf.f.d.ts

@@ -1,2 +1,2 @@
-import { type Rule } from '../bnf/func/module.f.ts';
+import { type Rule } from '../bnf/module.f.ts';
 export declare const wsModule: Rule;

package/fsc/bnf.f.js

@@ -1,54 +1,42 @@
-import { cp, range, remove, set, str } from "../bnf/func/module.f.js";
+import { range, remove, set, option } from "../bnf/module.f.js";
 import { digit, json, unicode, ws0, ws1, wsNoNewLine0 } from "./json.f.js";
-export const wsModule = () => [[ws0, module]];
-const module = () => [
-    [json, ws0],
-    [fjs],
-];
-const fjs = () => [
-    [],
-    [...str('const'), ws1, id, ws0, cp('='), ws0, json, wsNoNewLine0, fjsTail],
-    [...str('export'), ws1, ...str('default'), ws1, json],
-];
-const fjsTail = () => [
-    [],
-    [cp('\n'), ws0, fjs],
-];
+export const wsModule = () => [ws0, module];
+const module = () => ({
+    json: [json, ws0],
+    fjs,
+});
+const fjs = () => option({
+    const: ['const', ws1, id, ws0, '=', ws0, json, wsNoNewLine0, fjsTail],
+    export: ['export', ws1, 'default', ws1, json],
+});
+const fjsTail = option(['\n', ws0, fjs]);
 // line comment
-const lineItem = () => remove(unicode, [cp('\n')]);
-const line = () => [
-    [],
-    [lineItem, line]
-];
-const lineComment = () => [
-    [cp('/'), commentTail, cp('\n')]
-];
-const multiLineSkip = () => remove(unicode, [cp('/')]);
-const multiLineItem = () => remove(unicode, [cp('*')]);
-const multiLine = () => [
-    [cp('*'), multiLineTail],
-    [multiLineItem, multiLine]
-];
-const multiLineTail = () => [
-    [cp('/')],
-    [multiLineSkip, multiLine]
-];
-const commentTail = () => [
-    [cp('/'), lineComment],
-    [cp('*'), multiLine],
-];
+const lineItem = remove(unicode, set('\n'));
+const line = () => option([lineItem, line]);
+const lineComment = () => ['/', commentTail, '\n'];
+const multiLineSkip = remove(unicode, set('/'));
+const multiLineItem = remove(unicode, set('*'));
+const multiLine = () => ({
+    '*': ['*', multiLineTail],
+    '_': [multiLineItem, multiLine]
+});
+const multiLineTail = {
+    '/': '/',
+    '_': [multiLineSkip, multiLine]
+};
+const commentTail = {
+    '/': ['/', lineComment],
+    '*': ['*', multiLine],
+};
 // id
-const id = () => [[alpha, idTail0]];
-const alpha = () => [
-    [range('AZ')],
-    [range('az')],
-    ...set('_$'),
-];
-const idTail0 = () => [
-    [],
-    [alphaDigit, idTail0],
-];
-const alphaDigit = () => [
-    [alpha],
-    [digit],
-];
+const id = () => [alpha, idTail0];
+const alpha = {
+    upper: range('AZ'),
+    lower: range('az'),
+    _: set('_$'),
+};
+const idTail0 = () => option([alphaDigit, idTail0]);
+const alphaDigit = {
+    alpha,
+    digit,
+};

package/fsc/json.f.d.ts

@@ -1,4 +1,4 @@
-import { type Rule, type TerminalRange } from '../bnf/func/module.f.ts';
+import { type Rule, type TerminalRange } from '../bnf/module.f.ts';
 export declare const wsNoNewLine0: Rule;
 export declare const ws0: Rule;
 export declare const ws1: Rule;

package/fsc/json.f.js

@@ -1,89 +1,64 @@
-import { cp, join0, range, remove, repeat0, set, str } from "../bnf/func/module.f.js";
+import { join0Plus, rangeEncode, range, remove, repeat0Plus, set, option } from "../bnf/module.f.js";
 // space
-const wsNoNewLineItem = () => set(' \t\r');
-export const wsNoNewLine0 = () => [
-    [],
-    [wsNoNewLineItem, wsNoNewLine0],
-];
-const wsItem = () => [
-    [wsNoNewLineItem],
-    str('\n'),
-];
-export const ws0 = () => [
-    [],
-    [ws1],
-];
-export const ws1 = () => [
-    [wsItem, ws0]
-];
+const wsNoNewLineItem = set(' \t\r');
+export const wsNoNewLine0 = repeat0Plus(wsNoNewLineItem);
+const wsItem = {
+    wsNoNewLineItem,
+    n: '\n',
+};
+export const ws0 = () => option(ws1);
+export const ws1 = [wsItem, ws0];
 //
-export const json = () => [
-    [object],
-    [array],
-    [number],
-    [string],
-    str('true'),
-    str('false'),
-    str('null'),
-];
+export const json = () => ({
+    object,
+    array,
+    number,
+    string,
+    true: 'true',
+    false: 'false',
+    null: 'null',
+});
 //
-const separator = () => [[cp(','), ws0]];
+const separator = [',', ws0];
 // object
-const member = () => [[string, ws0, cp(':'), ws0, json, ws0]];
-const object = () => [
-    [cp('{'), ws0, join0(member, separator), cp('}')]
-];
+const member = () => [string, ws0, ':', ws0, json, ws0];
+const object = ['{', ws0, join0Plus(member, separator), '}'];
 // array
-const element = () => [
-    [json, ws0]
-];
-const array = () => [
-    [cp('['), ws0, join0(element, separator), cp(']')]
-];
+const element = [json, ws0];
+const array = ['[', ws0, join0Plus(element, separator), ']'];
 // string
-const character = () => [
-    ...remove(unicode, [cp('"'), cp('\\')]),
-    [cp('\\'), escape],
-];
-const string = () => [[cp('"'), repeat0(character), cp('"')]];
-export const unicode = [0x20, 0x10FFFF];
-const escape = () => [
+const character = () => ({
+    ...remove(unicode, set('"\\')),
+    '\\': ['\\', escape],
+});
+const string = ['"', repeat0Plus(character), '"'];
+export const unicode = rangeEncode(0x20, 0x10FFFF);
+const escape = () => ({
     ...set('"\\/bfnrt'),
-    [cp('u'), hex, hex, hex, hex] // 117
-];
-const hex = () => [
-    [digit],
-    [range('AF')],
-    [range('af')],
-];
+    'u': ['u', hex, hex, hex, hex] // 117
+});
+const hex = () => ({
+    digit,
+    upper: range('AF'),
+    lower: range('af'),
+});
 // number
-const number = () => [
-    [uNumber],
-    [cp('-'), uNumber],
-];
-const uNumber = () => [
-    [uint, fraction0, exponent0],
-];
-const uint = () => [
-    str('0'),
-    [range('19'), digits0]
-];
-export const digit = () => [[range('09')]];
-const digits0 = repeat0(digit);
-const digits1 = () => [
-    [digit, digits0]
-];
-const fraction0 = () => [
-    [],
-    [cp('.'), digits1]
-];
-const exponent0 = () => [
-    [],
-    [e, sign, digits1],
-];
-const e = () => set('eE');
-const sign = () => [
-    [],
-    [cp('+')],
-    [cp('-')],
-];
+const number = () => ({
+    uNumber,
+    minus: ['-', uNumber],
+});
+const uNumber = () => [uint, fraction0, exponent0];
+const uint = () => ({
+    '0': '0',
+    '19': [range('19'), digits0]
+});
+export const digit = range('09');
+const digits0 = repeat0Plus(digit);
+const digits1 = [digit, digits0];
+const fraction0 = option(['.', digits1]);
+const exponent0 = () => option([e, sign, digits1]);
+const e = set('eE');
+const sign = option({
+    '+': '+',
+    '-': '-',
+});

package/fsc/test.f.d.ts

@@ -1,4 +1,9 @@
 declare const _default: {
     a: () => void;
+    fn: () => void;
+    f1: () => void;
+    f2: () => void;
+    f3: () => void;
+    f4: () => void;
 };
 export default _default;

package/fsc/test.f.js

@@ -1,18 +1,80 @@
-import * as _ from "./module.f.js";
-import * as ascii from "../text/ascii/module.f.js";
-const { one } = ascii;
-import * as j from "../json/module.f.js";
-const { stringify } = j;
+import { init } from "./module.f.js";
+import { one } from "../text/ascii/module.f.js";
+import { stringify } from "../json/module.f.js";
 const s = stringify(i => i);
 const f = v => {
     const n = one(v);
-    return s(_.init(n)[0]);
+    return s(init(n)[0]);
 };
+// this doesn't change a name of the function
+const fn = (f, name) => ({ [name]: f }[name]);
+const withName = (name) => 
+// translated into one command: define a `function [name]() { return undefined }`
+Object.getOwnPropertyDescriptor({ [name]: () => undefined }, name).value;
 export default {
     a: () => {
         const x = f('1');
-        if (x != '["1"]') {
+        if (x !== '["1"]') {
             throw x;
         }
+    },
+    fn: () => {
+        const o = {
+            ["hello world!"]: () => undefined
+        };
+        const f = o["hello world!"];
+        const { name } = f;
+        if (name !== "hello world!") {
+            throw name;
+        }
+        //
+        const f1 = { ["boring"]: () => undefined }["boring"];
+        if (f1.name !== "boring") {
+            throw f1.name;
+        }
+        //
+        const x = fn(() => undefined, "hello").name;
+        if (x !== "") {
+            throw x;
+        }
+        //
+        const m = withName("boring2").name;
+        if (m !== "boring2") {
+            throw m;
+        }
+        //
+        const a = function x() { return undefined; };
+        if (a.name !== "x") {
+            throw a.name;
+        }
+    },
+    //
+    f1: () => {
+        const m1 = () => undefined;
+        if (m1.name !== "m1") {
+            throw m1.name;
+        }
+    },
+    //
+    f2: () => {
+        const m11 = (() => undefined);
+        if (m11.name !== "m11") {
+            throw m11.name;
+        }
+    },
+    //
+    f3: () => {
+        const m2 = true ? () => undefined : () => undefined;
+        // for `bun` it is `m2`:
+        // if (m2.name !== "") { throw m2.name }
+        // see also https://github.com/oven-sh/bun/issues/20398
+    },
+    f4: () => {
+        const id = (i) => i;
+        const f = id(() => undefined);
+        // for `bun` it is `m2`:
+        if (f.name !== "") {
+            throw f.name;
+        }
     }
 };

package/fsm/module.f.js

@@ -2,11 +2,11 @@ import { equal, isEmpty, fold, toArray, scan, foldScan, empty as emptyList } fro
 import { toRangeMap, union as byteSetUnion, one, empty, range } from "../types/byte_set/module.f.js";
 import { intersect, union as sortedSetUnion } from "../types/sorted_set/module.f.js";
 import { merge, get as rangeMapGet } from "../types/range_map/module.f.js";
-import { unsafeCmp } from "../types/function/compare/module.f.js";
 import { strictEqual } from "../types/function/operator/module.f.js";
 import { stringify } from "../json/module.f.js";
 import { identity } from "../types/function/module.f.js";
 import { stringToList } from "../text/utf16/module.f.js";
+import { cmp } from "../types/string/module.f.js";
 const stringifyIdentity = stringify(identity);
 export const toRange = s => {
     const [b, e] = toArray(stringToList(s));
@@ -17,8 +17,8 @@ export const toUnion = s => {
     const codePoints = stringToList(s);
     return fold(toUnionOp)(empty)(codePoints);
 };
-const mergeOp = { union: sortedSetUnion(unsafeCmp), equal: equal(strictEqual), def: [] };
-const hasState = s => set => !isEmpty(intersect(unsafeCmp)([s])(set));
+const mergeOp = { union: sortedSetUnion(cmp), equal: equal(strictEqual), def: [] };
+const hasState = s => set => !isEmpty(intersect(cmp)([s])(set));
 const foldOp = set => ([ruleIn, bs, ruleOut]) => rm => {
     if (hasState(ruleIn)(set)) {
         return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut));

package/fsm/test.f.js

@@ -1,24 +1,20 @@
-import * as _ from "./module.f.js";
-import * as byteSet from "../types/byte_set/module.f.js";
-import * as o from "../types/object/module.f.js";
-const { sort, fromEntries } = o;
-import * as json from "../json/module.f.js";
-import * as f from "../types/function/module.f.js";
-const { identity } = f;
-import * as list from "../types/list/module.f.js";
-const { toArray } = list;
-import * as utf16 from "../text/utf16/module.f.js";
-const { stringToList } = utf16;
-const stringifyIdentity = json.stringify(identity);
+import { dfa, run, toRange, toUnion } from "./module.f.js";
+import { union } from "../types/byte_set/module.f.js";
+import { sort, fromEntries } from "../types/object/module.f.js";
+import { stringify } from "../json/module.f.js";
+import { identity } from "../types/function/module.f.js";
+import { toArray } from "../types/list/module.f.js";
+import { stringToList } from "../text/utf16/module.f.js";
+const stringifyIdentity = stringify(identity);
 const buildDfa = () => {
-    const lowercaseAlpha = _.toRange('az');
-    const uppercaseAlpha = _.toRange('AZ');
-    const alpha = byteSet.union(lowercaseAlpha)(uppercaseAlpha);
-    const idSymbol = _.toUnion('_$');
-    const idBegin = byteSet.union(alpha)(idSymbol);
-    const digit = _.toRange('09');
-    const idNext = byteSet.union(idBegin)(digit);
-    const dot = _.toUnion('.');
+    const lowercaseAlpha = toRange('az');
+    const uppercaseAlpha = toRange('AZ');
+    const alpha = union(lowercaseAlpha)(uppercaseAlpha);
+    const idSymbol = toUnion('_$');
+    const idBegin = union(alpha)(idSymbol);
+    const digit = toRange('09');
+    const idNext = union(idBegin)(digit);
+    const dot = toUnion('.');
     const grammar = [
         ['', digit, 'int'],
         ['int', digit, 'int'],
@@ -30,7 +26,7 @@ const buildDfa = () => {
         ['', idBegin, 'id'],
         ['id', idNext, 'id']
     ];
-    return _.dfa(grammar);
+    return dfa(grammar);
 };
 export default {
     dfa: () => {
@@ -83,7 +79,7 @@ export default {
         () => {
             const dfa = buildDfa();
             const input = stringToList('a1');
-            const result = stringifyIdentity(toArray(_.run(dfa)(input)));
+            const result = stringifyIdentity(toArray(run(dfa)(input)));
             const expectedOutput = [
                 '["id"]',
                 '["id"]'
@@ -96,7 +92,7 @@ export default {
         () => {
             const dfa = buildDfa();
             const input = stringToList('0.1');
-            const result = stringifyIdentity(toArray(_.run(dfa)(input)));
+            const result = stringifyIdentity(toArray(run(dfa)(input)));
             const expectedOutput = [
                 '["floatBegin","int"]',
                 '["floatDot"]',
@@ -110,7 +106,7 @@ export default {
         () => {
             const dfa = buildDfa();
             const input = stringToList('//');
-            const result = stringifyIdentity(toArray(_.run(dfa)(input)));
+            const result = stringifyIdentity(toArray(run(dfa)(input)));
             const expectedOutput = [
                 '[]',
                 '[]'
@@ -123,7 +119,7 @@ export default {
         () => {
             const dfa = buildDfa();
             const input = stringToList('::');
-            const result = stringifyIdentity(toArray(_.run(dfa)(input)));
+            const result = stringifyIdentity(toArray(run(dfa)(input)));
             const expectedOutput = [
                 '[]',
                 '[]'

package/html/module.f.js

@@ -1,5 +1,5 @@
 import { map, flatMap, flat, concat as listConcat } from "../types/list/module.f.js";
-import { concat as stringConcat } from "../types/string/module.f.js";
+import { concat, concat as stringConcat } from "../types/string/module.f.js";
 import { compose } from "../types/function/module.f.js";
 import { stringToList } from "../text/utf16/module.f.js";
 const { fromCharCode } = String;
@@ -25,6 +25,14 @@ const voidTagList = [
     'track',
     'wbr',
 ];
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script
+ * https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/style
+ */
+const rawText = [
+    'script',
+    'style'
+];
 /**
  * https://stackoverflow.com/questions/7381974/which-characters-need-to-be-escaped-in-html
  */
@@ -40,6 +48,10 @@ const escapeCharCode = (code) => {
 const escape = compose(stringToList)(map(escapeCharCode));
 const node = (n) => typeof n === 'string' ? escape(n) : element(n);
 const nodes = flatMap(node);
+const raw = (n) => typeof n === 'string' ? n : '';
+const mr = map(raw);
+// Escape closing tags in raw text elements
+const rawMap = (n) => concat(mr(n)).replaceAll('</', '<\\/');
 const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']]);
 const attributes = compose(entries)(flatMap(attribute));
 const parseElement = (e) => {
@@ -53,9 +65,10 @@ const parseElement = (e) => {
 export const element = (e) => {
     const [tag, a, n] = parseElement(e);
     const open = flat([[`<`, tag], attributes(a), [`>`]]);
-    return voidTagList.includes(tag) ?
-        open :
-        flat([open, nodes(n), ['</', tag, '>']]);
+    if (voidTagList.includes(tag)) {
+        return open;
+    }
+    return flat([open, rawText.includes(tag) ? [rawMap(n)] : nodes(n), ['</', tag, '>']]);
 };
 export const html = compose(element)(listConcat(['<!DOCTYPE html>']));
 export const htmlToString = compose(html)(stringConcat);