functionalscript 0.2.4 → 0.2.6

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 {};

package/out/html/module.f.mjs

@@ -12,7 +12,7 @@ const { fromCharCode } = String;
 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',
@@ -27,20 +27,20 @@ const voidTagList = [
     'source',
     'track',
     'wbr',
-];
+]);
+/** @typedef {typeof voidTagList} VoidTagList */
+/** @typedef {keyof voidTagList} VoidTag */
 /** @type {(tag: string) => boolean} */
-const isVoid = tag => voidTagList.includes(tag);
-/** @typedef {readonly[Tag]} Element1*/
-/** @typedef {readonly[Tag, Attributes]} Element2A */
-/** @typedef {readonly[Tag, readonly Node[]]} Element2N */
-/** @typedef {readonly[Tag, Attributes, Nodes]} Element3*/
-/** @typedef {Element1 | Element2A | Element2N | Element3} Element */
+const isVoid = tag => voidTagList.includes(/** @type {any} */ (tag));
+/** @typedef {readonly[Tag, ...Node[]]} Element1*/
+/** @typedef {readonly[Tag, Attributes, ...Node[]]} Element2 */
+/** @typedef {Element1 | Element2 } Element */
 /**
  * @typedef {{
  *  readonly[k in string]: string
  * }} Attributes
  */
-/** @typedef {list.List<Node>} Nodes */
+// /** @typedef {list.List<Node>} Nodes */
 /** @typedef {Element | string} Node */
 /**
  * https://stackoverflow.com/questions/7381974/which-characters-need-to-be-escaped-in-html
@@ -64,31 +64,17 @@ const nodes = flatMap(node);
 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 {(_: 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) => (a: Attributes) => list.List<string>} */
+const open = t => a => flat([[`<`, t], attributes(a), [`>`]]);
+/** @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>']));
 export const htmlToString = compose(html)(stringConcat);

package/out/html/test.f.mjs

@@ -1,9 +1,9 @@
 import * as _ from './module.f.mjs';
 export default {
     empty: () => {
-        const r = _.htmlToString(['html', []]);
+        const r = _.htmlToString(['html']);
         if (r !== '<!DOCTYPE html><html></html>') {
-            throw r;
+            throw `empty: ${r}`;
         }
     },
     empty2: () => {
@@ -20,7 +20,7 @@ export default {
     },
     some: () => {
         /** @type {_.Element} */
-        const x = ['div', {}, ['<div>&amp;</div>', ['a', { href: 'hello"' }, []]]];
+        const x = ['div', {}, '<div>&amp;</div>', ['a', { href: 'hello"' }]];
         const s = _.htmlToString(x);
         if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
             throw s;
@@ -28,7 +28,7 @@ export default {
     },
     some2: () => {
         /** @type {_.Element} */
-        const x = ['div', ['<div>&amp;</div>', ['a', { href: 'hello"' }, []]]];
+        const x = ['div', '<div>&amp;</div>', ['a', { href: 'hello"' }]];
         const s = _.htmlToString(x);
         if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
             throw s;
@@ -36,7 +36,7 @@ export default {
     },
     someVoid: () => {
         /** @type {_.Element} */
-        const x = ['div', [['br', { id: '5' }], '<div>&amp;</div>', ['a', { href: 'hello"' }, []]]];
+        const x = ['div', ['br', { id: '5' }], '<div>&amp;</div>', ['a', { href: 'hello"' }]];
         const s = _.htmlToString(x);
         if (s !== '<!DOCTYPE html><div><br id="5">&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
             throw s;

package/out/js/tokenizer/module.f.d.mts

@@ -34,6 +34,9 @@ export type FalseToken = {
 export type NullToken = {
     readonly kind: "null";
 };
+export type UndefinedToken = {
+    readonly kind: "undefined";
+};
 export type KeywordToken = {
     readonly kind: "arguments" | "await" | "break" | "case" | "catch" | "class" | "const" | "continue";
 } | {
@@ -74,9 +77,13 @@ export type OperatorToken = {
 } | {
     readonly kind: "?" | "?." | "=>";
 };
-export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | NewLineToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | OperatorToken;
-export type TokenizerState = InitialState | ParseIdState | ParseStringState | ParseEscapeCharState | ParseUnicodeCharState | ParseNumberState | InvalidNumberState | ParseOperatorState | ParseMinusState | ParseWhitespaceState | ParseNewLineState | EofState;
-export type ErrorMessage = "\" are missing" | "unescaped character" | "invalid hex value" | "unexpected character" | "invalid number" | "invalid token" | "eof";
+export type CommentToken = {
+    readonly kind: "//" | "/*";
+    readonly value: string;
+};
+export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | NewLineToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | UndefinedToken | OperatorToken | CommentToken;
+export type TokenizerState = InitialState | ParseIdState | ParseStringState | ParseEscapeCharState | ParseUnicodeCharState | ParseNumberState | InvalidNumberState | ParseOperatorState | ParseWhitespaceState | ParseNewLineState | ParseCommentState | EofState;
+export type ErrorMessage = "\" are missing" | "unescaped character" | "invalid hex value" | "unexpected character" | "invalid number" | "invalid token" | "*/ expected" | "unterminated string literal" | "eof";
 export type InitialState = {
     readonly kind: "initial";
 };
@@ -105,6 +112,11 @@ export type ParseOperatorState = {
 export type ParseMinusState = {
     readonly kind: "-";
 };
+export type ParseCommentState = {
+    readonly kind: "//" | "/*" | "/**";
+    readonly value: string;
+    readonly newLine: boolean;
+};
 export type ParseUnicodeCharState = {
     readonly kind: "unicodeChar";
     readonly value: string;

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

@@ -54,6 +54,7 @@ leftCurlyBracket, rightCurlyBracket, dollarSign } = ascii.ascii;
 /** @typedef {{readonly kind: 'true'}} TrueToken */
 /** @typedef {{readonly kind: 'false'}} FalseToken */
 /** @typedef {{readonly kind: 'null'}} NullToken */
+/** @typedef {{readonly kind: 'undefined'}} UndefinedToken */
 /**
  * @typedef {|
  * {readonly kind: 'arguments' | 'await' | 'break' | 'case' | 'catch' | 'class' | 'const' | 'continue' } |
@@ -85,6 +86,12 @@ leftCurlyBracket, rightCurlyBracket, dollarSign } = ascii.ascii;
 * {readonly kind: '?' | '?.' | '=>'}
 * } OperatorToken
 */
+/**
+ * @typedef {{
+* readonly kind: '//' | '/*'
+* readonly value: string
+* }} CommentToken
+* */
 /**
  * @typedef {|
 * KeywordToken |
@@ -98,7 +105,9 @@ leftCurlyBracket, rightCurlyBracket, dollarSign } = ascii.ascii;
 * ErrorToken |
 * IdToken |
 * BigIntToken |
-* OperatorToken
+* UndefinedToken |
+* OperatorToken |
+* CommentToken
 * } JsToken
 */
 const rangeOneNine = range('19');
@@ -178,20 +187,22 @@ const rangeId = [digitRange, ...rangeIdStart];
  * ParseNumberState |
  * InvalidNumberState |
  * ParseOperatorState |
- * ParseMinusState |
  * ParseWhitespaceState |
  * ParseNewLineState |
+ * ParseCommentState |
  * EofState
  * } TokenizerState
  */
 /**
  * @typedef {|
-  * '" are missing' |
+ * '" are missing' |
  * 'unescaped character' |
  * 'invalid hex value' |
  * 'unexpected character' |
  * 'invalid number' |
  * 'invalid token' |
+ * '*\/ expected' |
+ * 'unterminated string literal' |
  * 'eof'
  * } ErrorMessage
  */
@@ -203,6 +214,13 @@ const rangeId = [digitRange, ...rangeIdStart];
 /** @typedef {{ readonly kind: 'escapeChar', readonly value: string}} ParseEscapeCharState */
 /** @typedef {{ readonly kind: 'op', readonly value: string}} ParseOperatorState */
 /** @typedef {{ readonly kind: '-'}} ParseMinusState */
+/**
+ *  @typedef {{
+ *  readonly kind: '//' | '/*' | '/**'
+ *  readonly value: string
+ *  readonly newLine: boolean
+ * }} ParseCommentState
+ */
 /**
  * @typedef {{
  *  readonly kind: 'unicodeChar'
@@ -213,7 +231,7 @@ const rangeId = [digitRange, ...rangeIdStart];
  */
 /**
  * @typedef {{
- *  readonly kind: 'number',
+ *  readonly kind: 'number'
  *  readonly numberKind: '0' | 'int' | '.' | 'fractional' | 'e' | 'e+' | 'e-' | 'expDigits' | 'bigint'
  *  readonly value: string
  *  readonly b: ParseNumberBuffer
@@ -352,6 +370,7 @@ const keywordEntries = [
     ['true', { kind: 'true' }],
     ['try', { kind: 'try' }],
     ['typeof', { kind: 'typeof' }],
+    ['undefined', { kind: 'undefined' }],
     ['var', { kind: 'var' }],
     ['void', { kind: 'void' }],
     ['while', { kind: 'while' }],
@@ -431,8 +450,8 @@ const hasOperatorToken = op => at(op)(operatorMap) !== null;
 const initialStateOp = create(state => () => [[{ kind: 'error', message: 'unexpected character' }], state])([
     rangeFunc(rangeOneNine)(() => input => [empty, { kind: 'number', value: fromCharCode(input), b: startNumber(input), numberKind: 'int' }]),
     rangeSetFunc(rangeIdStart)(() => input => [empty, { kind: 'id', value: fromCharCode(input) }]),
-    rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, { kind: 'ws' }]),
-    rangeSetFunc(rangeSetNewLine)(state => () => [empty, { kind: 'nl' }]),
+    rangeSetFunc(rangeSetWhiteSpace)(() => () => [empty, { kind: 'ws' }]),
+    rangeSetFunc(rangeSetNewLine)(() => () => [empty, { kind: 'nl' }]),
     rangeFunc(one(quotationMark))(() => () => [empty, { kind: 'string', value: '' }]),
     rangeFunc(one(digit0))(() => input => [empty, { kind: 'number', value: fromCharCode(input), b: startNumber(input), numberKind: '0' }]),
     rangeSetFunc(rangeOpStart)(() => input => [empty, { kind: 'op', value: fromCharCode(input) }])
@@ -550,16 +569,11 @@ const invalidNumberStateOp = create(() => () => [empty, { kind: 'invalidNumber'
         return [{ first: { kind: 'error', message: 'invalid number' }, tail: next[0] }, next[1]];
     })
 ]);
-/** @type {(state: ParseMinusState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
-const parseMinusStateOp = create(() => input => tokenizeOp({ kind: 'op', value: '-' })(input))([
-    rangeFunc(one(fullStop))(() => input => tokenizeOp({ kind: 'invalidNumber' })(input)),
-    rangeFunc(one(digit0))(() => () => [empty, { kind: 'number', value: '-0', b: startNegativeNumber, numberKind: '0' }]),
-    rangeFunc(rangeOneNine)(() => input => [empty, { kind: 'number', value: appendChar('-')(input), b: addIntDigit(input)(startNegativeNumber), numberKind: 'int' }]),
-]);
 /** @type {(state: ParseStringState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseStringStateOp = create(state => input => [empty, { kind: 'string', value: appendChar(state.value)(input) }])([
     rangeFunc(one(quotationMark))(state => () => [[{ kind: 'string', value: state.value }], { kind: 'initial' }]),
-    rangeFunc(one(reverseSolidus))(state => () => [empty, { kind: 'escapeChar', value: state.value }])
+    rangeFunc(one(reverseSolidus))(state => () => [empty, { kind: 'escapeChar', value: state.value }]),
+    rangeSetFunc(rangeSetNewLine)(() => () => [[{ kind: 'error', message: 'unterminated string literal' }], { kind: 'nl' }])
 ]);
 /** @type {(state: ParseEscapeCharState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseEscapeDefault = state => input => {
@@ -610,20 +624,45 @@ const parseIdStateOp = create(parseIdDefault)([
 /** @type {(state: ParseOperatorState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseOperatorStateOp = state => input => {
     const nextStateValue = appendChar(state.value)(input);
-    if (hasOperatorToken(nextStateValue))
-        return [empty, { kind: 'op', value: nextStateValue }];
-    const next = tokenizeOp({ kind: 'initial' })(input);
-    return [{ first: getOperatorToken(state.value), tail: next[0] }, next[1]];
+    switch (nextStateValue) {
+        case '//': return [empty, { kind: '//', value: '', newLine: false }];
+        case '/*': return [empty, { kind: '/*', value: '', newLine: false }];
+        default: {
+            if (hasOperatorToken(nextStateValue))
+                return [empty, { kind: 'op', value: nextStateValue }];
+            const next = tokenizeOp({ kind: 'initial' })(input);
+            return [{ first: getOperatorToken(state.value), tail: next[0] }, next[1]];
+        }
+    }
 };
+/** @type {(state: ParseCommentState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
+const parseSinglelineCommentStateOp = create(state => input => [empty, { ...state, value: appendChar(state.value)(input) }])([
+    rangeSetFunc(rangeSetNewLine)(state => () => [[{ kind: '//', value: state.value }], { kind: 'nl' }])
+]);
+/** @type {(state: ParseCommentState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
+const parseMultilineCommentStateOp = create(state => input => [empty, { ...state, value: appendChar(state.value)(input) }])([
+    rangeFunc(one(asterisk))(state => () => [empty, { ...state, kind: '/**' }]),
+    rangeSetFunc(rangeSetNewLine)(state => input => [empty, { ...state, value: appendChar(state.value)(input), newLine: true }]),
+]);
+/** @type {(state: ParseCommentState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
+const parseMultilineCommentAsteriskStateOp = create(state => input => [empty, { ...state, kind: '/*', value: appendChar(appendChar(state.value)(asterisk))(input) }])([
+    rangeFunc(one(asterisk))(state => () => [empty, { ...state, value: appendChar(state.value)(asterisk) }]),
+    rangeSetFunc(rangeSetNewLine)(state => input => [empty, { kind: '/*', value: appendChar(appendChar(state.value)(asterisk))(input), newLine: true }]),
+    rangeFunc(one(solidus))(state => () => {
+        /** @type {list.List<JsToken>} */
+        const tokens = state.newLine ? [{ kind: '/*', value: state.value }, { kind: 'nl' }] : [{ kind: '/*', value: state.value }];
+        return [tokens, { kind: 'initial' }];
+    })
+]);
 /** @type {(state: ParseWhitespaceState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
-const parseWhitespaceDefault = state => input => {
+const parseWhitespaceDefault = () => input => {
     const next = tokenizeOp({ kind: 'initial' })(input);
     return [{ first: { kind: 'ws' }, tail: next[0] }, next[1]];
 };
 /** @type {(state: ParseWhitespaceState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseWhitespaceStateOp = create(parseWhitespaceDefault)([
     rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, state]),
-    rangeSetFunc(rangeSetNewLine)(state => () => [empty, { kind: 'nl' }])
+    rangeSetFunc(rangeSetNewLine)(() => () => [empty, { kind: 'nl' }])
 ]);
 /** @type {(state: ParseNewLineState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseNewLineDefault = state => input => {
@@ -648,7 +687,9 @@ const tokenizeCharCodeOp = state => {
         case 'invalidNumber': return invalidNumberStateOp(state);
         case 'number': return parseNumberStateOp(state);
         case 'op': return parseOperatorStateOp(state);
-        case '-': return parseMinusStateOp(state);
+        case '//': return parseSinglelineCommentStateOp(state);
+        case '/*': return parseMultilineCommentStateOp(state);
+        case '/**': return parseMultilineCommentAsteriskStateOp(state);
         case 'ws': return parseWhitespaceStateOp(state);
         case 'nl': return parseNewLineStateOp(state);
         case 'eof': return eofStateOp(state);
@@ -668,11 +709,13 @@ const tokenizeEofOp = state => {
                 case '.':
                 case 'e':
                 case 'e+':
-                case 'e-': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'invalidNumber', }];
+                case 'e-': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'eof', }];
                 default: return [[bufferToNumberToken(state)], { kind: 'eof' }];
             }
         case 'op': return [[getOperatorToken(state.value)], { kind: 'eof' }];
-        case '-': return [[{ kind: '-' }], { kind: 'eof' }];
+        case '//': return [[{ kind: '//', value: state.value }], { kind: 'eof' }];
+        case '/*':
+        case '/**': return [[{ kind: 'error', message: '*/ expected' }], { kind: 'eof', }];
         case 'ws': return [[{ kind: 'ws' }], { kind: 'eof' }];
         case 'nl': return [[{ kind: 'nl' }], { kind: 'eof' }];
         case 'eof': return [[{ kind: 'error', message: 'eof' }], state];

package/out/js/tokenizer/test.f.d.mts

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

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

@@ -124,6 +124,18 @@ export default {
                 throw result;
             }
         },
+        () => {
+            const result = stringify(tokenizeString('"\r"'));
+            if (result !== '[{"kind":"error","message":"unterminated string literal"},{"kind":"nl"},{"kind":"error","message":"\\" are missing"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(tokenizeString('"\n null'));
+            if (result !== '[{"kind":"error","message":"unterminated string literal"},{"kind":"nl"},{"kind":"null"}]') {
+                throw result;
+            }
+        },
         () => {
             const result = stringify(tokenizeString('"\\b\\f\\n\\r\\t"'));
             if (result !== '[{"kind":"string","value":"\\b\\f\\n\\r\\t"}]') {
@@ -564,6 +576,12 @@ 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":"]"}]') {
@@ -840,5 +858,49 @@ export default {
                 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/json/parser/test.f.mjs

@@ -317,5 +317,13 @@ export default {
                 throw result;
             }
         },
+        () => {
+            const tokenList = tokenizeString('undefined');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
     ]
 };

package/out/types/bit_vec/module.f.d.mts

@@ -10,62 +10,148 @@ export const empty: 1n;
 /**
  * Calculates the length of the given vector of bits.
  */
-export const len: (v: bigint) => bigint;
+export const length: (v: bigint) => bigint;
 /**
- * Extract an unsigned integer of the given `uintLen` from the given vector.
+ * Creates a vector of bits of the given `len` and the given unsigned integer.
+ *
+ * @type {(len: bigint) => (ui: bigint) => Vec}
+ *
+ * @example
+ *
+ * ```js
+ * const vec4 = vec(4n)
+ * const v0 = vec4(5n)     // 0x15n
+ * const v1 = vec4(0x5FEn) // 0x1En
+ * ```
+ */
+export const vec: (len: bigint) => (ui: bigint) => Vec;
+/**
+ * Returns the unsigned integer of the given vector by removing a stop bit.
+ *
+ * @type {(len: Vec) => bigint}
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0x5n) // 0x105n
+ * const result = uint(vector); // result is 0x5n
+ * ```
+ */
+export const uint: (len: Vec) => bigint;
+/**
+ * Extract the least significant unsigned integer from the given vector.
  *
  * @type {(uintLen: bigint) => (v: Vec) => bigint}
  *
  * @example
  *
  * ```js
- * const vector = 0b110101n;
- * const extract3Bits = uint(3n);
- * const result = extract3Bits(vector); // result is 0b101n (5n)
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const result = uintLsb(4n)(vector); // result is 5n
+ * const result2 = uintLsb(16n)(vector); // result2 is 0xF5n
  * ```
  */
-export const uint: (uintLen: bigint) => (v: Vec) => bigint;
+export const uintLsb: (uintLen: bigint) => (v: Vec) => bigint;
 /**
- * Creates a vector of bits of the given `vecLen` from the given unsigned integer.
+ * Removes the first `len` least significant bits from the given vector.
  *
- * @type {(vecLen: bigint) => (ui: bigint) => Vec}
+ * @type {(len: bigint) => (v: Vec) => Vec}
  *
  * @example
  *
  * ```js
- * const createVector = vec(4n);
- * const vector = createVector(5n); // vector is 0b10101n
+ * const v = vec(16n)(0x3456n) // 0x13456n
+ * const r = removeLsb(4n)(v) // 0x1345n
+ * const r2 = removeLsb(24n)(v) // 0x1n
  * ```
  */
-export const vec: (vecLen: bigint) => (ui: bigint) => Vec;
+export const removeLsb: (len: bigint) => (v: Vec) => Vec;
 /**
- * Appends the vector `b` to the back of the vector `a`.
+ * Extracts the least significant unsigned integer and removes it from the vector.
  *
- * @type {(a: Vec) => (b: Vec) => Vec}
+ * @type {(len: bigint) => (v: Vec) => [bigint, Vec]}
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const [result, rest] = popUintLsb(4n)(vector); // result is 5n, rest is 0x1Fn
+ * const [result2, rest2] = popUintLsb(16n)(vector); // result2 is 0xF5n, rest2 is 1n
+ * ```
+ */
+export const popUintLsb: (len: bigint) => (v: Vec) => [bigint, Vec];
+/**
+ * Extract the most significant unsigned integer of the given `len` from the given vector.
+ *
+ * @type {(len: bigint) => (v: Vec) => bigint}
  *
  * @example
  *
  * ```js
- * const vec8 = vec(8n)
- * const a = vec8(0x345n)
- * const b = vec8(0x789n)
- * const ab = appendBack(a)(b) // 0x18945n
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const result = uintMsb(4n)(vector); // result is 0xFn
+ * const result2 = uintMsb(16n)(vector); // result2 is 0xF500n
  * ```
  */
-export const appendBack: (a: Vec) => (b: Vec) => Vec;
+export const uintMsb: (len: bigint) => (v: Vec) => bigint;
 /**
- * Removes the first `len` bits from the given vector.
+ * Removes the first `len` most significant bits from the given vector.
  *
  * @type {(len: bigint) => (v: Vec) => Vec}
  *
  * @example
  *
  * ```js
- * const v = vec(17n)(0x12345n) // v = 0x32345n
- * const r = removeFront(9n)(v) // r = 0x191n
+ * const v = vec(16n)(0x3456n) // 0x13456n
+ * const r = removeMsb(4n)(v) // 0x1456n
+ * const r2 = removeMsb(24n)(v) // 0x1n
+ * ```
+ */
+export const removeMsb: (len: bigint) => (v: Vec) => Vec;
+/**
+ * Extracts the most significant unsigned integer and removes it from the vector.
+ *
+ * @type {(len: bigint) => (v: Vec) => [bigint, Vec]}
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const [result, rest] = popUintMsb(4n)(vector); // [0xFn, 0x15n]
+ * const [result2, rest2] = popUintMsb(16n)(vector); // [0xF500n, 1n]
+ * ```
+ */
+export const popUintMsb: (len: bigint) => (v: Vec) => [bigint, Vec];
+/**
+ * Concat the given vectors of bits. The first vector is the least significant.
+ *
+ * @type {(a: Vec) => (b: Vec) => Vec}
+ *
+ * @example
+ *
+ * ```js
+ * const u8 = vec(8n)
+ * const a = u8(0x45n) // 0x145n
+ * const b = u8(0x89n) // 0x189n
+ * const ab = concatLsb(a)(b) // 0x18945n
+ * ```
+ */
+export const concatLsb: (a: Vec) => (b: Vec) => Vec;
+/**
+ * Concat the given vectors of bits. The first vector is the most significant.
+ *
+ * @type {(b: Vec) => (a: Vec) => Vec}
+ *
+ * @example
+ *
+ * ```js
+ * const u8 = vec(8n)
+ * const a = u8(0x45n) // 0x145n
+ * const b = u8(0x89n) // 0x189n
+ * const ab = concatMsb(a)(b) // 0x14589n
  * ```
  */
-export const removeFront: (len: bigint) => (v: Vec) => Vec;
+export const concatMsb: (b: Vec) => (a: Vec) => Vec;
 /**
  * A vector of bits represented as a `bigint`.
  */