functionalscript 0.2.4 → 0.2.5

package/out/djs/module.f.d.mts

@@ -12,7 +12,7 @@ export const serialize: (mapEntries: MapEntries) => (value: Unknown) => list.Lis
 export const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
 export type Object = { readonly [k in string]: Unknown; };
 export type Array = readonly Unknown[];
-export type Unknown = Object | boolean | string | number | null | Array | bigint;
+export type Unknown = Object | boolean | string | number | null | Array | bigint | undefined;
 export type Entry = O.Entry<Unknown>;
 export type Entries = (list.List<Entry>);
 export type MapEntries = (entries: Entries) => Entries;

package/out/djs/module.f.mjs

@@ -17,8 +17,9 @@ const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize,
  * }} Object
  */
 /** @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 */
 /** @typedef {(entries: Entries) => Entries} MapEntries */
@@ -56,6 +57,9 @@ export const serialize = sort => {
                 if (value === null) {
                     return nullSerialize;
                 }
+                if (value === undefined) {
+                    return undefinedSerialize;
+                }
                 if (value instanceof Array) {
                     return arraySerialize(value);
                 }

package/out/djs/parser/module.f.d.mts

@@ -1,7 +1,7 @@
 /** @type {(tokenList: list.List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>} */
 export const parse: (tokenList: list.List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>;
 export type DjsModule = [readonly string[], readonly DjsConst[]];
-export type DjsConst = boolean | string | number | null | bigint | DjsModuleRef | DjsArray | DjsObject;
+export type DjsConst = boolean | string | number | null | bigint | undefined | DjsModuleRef | DjsArray | DjsObject;
 export type DjsModuleRef = ["aref" | "cref", number];
 export type DjsArray = ["array", readonly DjsConst[]];
 export type DjsObject = { readonly [k in string]: DjsConst; };

package/out/djs/parser/module.f.mjs

@@ -9,7 +9,7 @@ const { setReplace, at } = map;
 import * as o from '../../types/object/module.f.mjs';
 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 */
 /** @typedef {['array', readonly DjsConst[]]} DjsArray */
 /**
@@ -89,7 +89,9 @@ const { fromMap } = o;
 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' };
@@ -103,7 +105,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' };
     }
@@ -112,7 +116,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 };
@@ -120,11 +126,23 @@ 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' };
@@ -140,7 +158,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' };
     }
@@ -149,7 +169,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' };
@@ -165,7 +187,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' };
@@ -177,7 +201,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 } };
@@ -257,6 +283,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;
     }
 };
@@ -268,7 +295,8 @@ const isValueToken = token => {
         case 'true':
         case 'number':
         case 'string':
-        case 'bigint': return true;
+        case 'bigint':
+        case 'undefined': return true;
         default: return false;
     }
 };
@@ -277,119 +305,107 @@ 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;
+    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' };
     }
-    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;
+    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' };
     }
-    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;
+    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' };
     }
-    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;
+    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' };
     }
-    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;
+    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' };
     }
-    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;
+    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' };
     }
-    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;
+    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' };
     }
-    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;
+    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' };
     }
-    return { state: 'error', message: 'unexpected token' };
 };
 /** @type {Operator.Fold<tokenizerT.DjsToken, ParserState>} */
 const foldOp = token => state => {
@@ -402,7 +418,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/out/djs/parser/test.f.d.mts

@@ -8,5 +8,6 @@ declare namespace _default {
     let invalidWithConst: (() => void)[];
     let validWithArgs: (() => void)[];
     let invalidWithArgs: (() => void)[];
+    let comments: (() => void)[];
 }
 export default _default;

package/out/djs/parser/test.f.mjs

@@ -35,6 +35,14 @@ export default {
                 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);
@@ -108,10 +116,10 @@ export default {
             }
         },
         () => {
-            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}]]]') {
+            if (result !== '["ok",[[],[{"a":true,"b":false,"c":null,"d":undefined}]]]') {
                 throw result;
             }
         },
@@ -336,7 +344,7 @@ 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]]]]]') {
@@ -344,7 +352,23 @@ export default {
             }
         },
         () => {
-            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}]]]') {
@@ -532,4 +556,14 @@ export default {
             }
         },
     ],
+    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/out/djs/tokenizer/module.f.d.mts

@@ -1,10 +1,10 @@
 /** @type {(input: list.List<number>) => list.List<DjsToken>} */
 export const tokenize: (input: list.List<number>) => list.List<DjsToken>;
 export type DjsToken = {
-    readonly kind: "true" | "false" | "null";
+    readonly kind: "true" | "false" | "null" | "undefined";
 } | {
     readonly kind: "{" | "}" | ":" | "," | "[" | "]" | "." | "=";
-} | jsTokenizer.StringToken | jsTokenizer.NumberToken | jsTokenizer.ErrorToken | jsTokenizer.IdToken | jsTokenizer.BigIntToken | jsTokenizer.WhitespaceToken | jsTokenizer.NewLineToken;
+} | jsTokenizer.StringToken | jsTokenizer.NumberToken | jsTokenizer.ErrorToken | jsTokenizer.IdToken | jsTokenizer.BigIntToken | jsTokenizer.WhitespaceToken | jsTokenizer.NewLineToken | jsTokenizer.CommentToken;
 export type ScanState = {
     readonly kind: "def" | "-";
 };

package/out/djs/tokenizer/module.f.mjs

@@ -7,7 +7,7 @@ const { multiply } = bf;
 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 |
@@ -15,7 +15,8 @@ import * as jsTokenizer from '../../js/tokenizer/module.f.mjs';
 * jsTokenizer.IdToken |
 * jsTokenizer.BigIntToken |
 * jsTokenizer.WhitespaceToken |
-* jsTokenizer.NewLineToken
+* jsTokenizer.NewLineToken |
+* jsTokenizer.CommentToken
 * } DjsToken
 */
 /**
@@ -48,6 +49,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/out/djs/tokenizer/test.f.d.mts

@@ -2,5 +2,6 @@ declare namespace _default {
     let djs: (() => void)[];
     let id: (() => void)[];
     let keywords: (() => void)[];
+    let comments: (() => void)[];
 }
 export default _default;

package/out/djs/tokenizer/test.f.mjs

@@ -470,11 +470,61 @@ export default {
                 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/out/html/module.f.d.mts

@@ -3,13 +3,15 @@ export const element: (element: Element) => list.List<string>;
 export const html: f.Func<Element, list.List<string>>;
 export const htmlToString: f.Func<Element, string>;
 export type Tag = string;
-export type Element1 = readonly [Tag];
-export type Element2A = readonly [Tag, Attributes];
-export type Element2N = readonly [Tag, readonly Node[]];
-export type Element3 = readonly [Tag, Attributes, Nodes];
-export type Element = Element1 | Element2A | Element2N | Element3;
+export type VoidTagList = typeof voidTagList;
+export type VoidTag = keyof readonly ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"];
+export type Element1 = readonly [Tag, ...Node[]];
+export type Element2 = readonly [Tag, Attributes, ...Node[]];
+export type Element = Element1 | Element2;
 export type Attributes = { readonly [k in string]: string; };
-export type Nodes = list.List<Node>;
 export type Node = Element | string;
 import * as list from '../types/list/module.f.mjs';
 import * as f from '../types/function/module.f.mjs';
+/** @typedef {string} Tag */
+declare const voidTagList: readonly ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"];
+export {};