functionalscript 0.2.5 → 0.3.0

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

@@ -1,448 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as result from '../../types/result/module.f.mjs';
-import * as list from '../../types/list/module.f.mjs';
-const { fold, first, drop, toArray, map: listMap, length } = list;
-import * as Operator from '../../types/function/operator/module.f.mjs';
-import * as tokenizerT from '../tokenizer/module.f.mjs';
-import * as map from '../../types/map/module.f.mjs';
-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|undefined|DjsModuleRef|DjsArray|DjsObject} DjsConst */
-/** @typedef {['aref' | 'cref', number]} DjsModuleRef */
-/** @typedef {['array', readonly DjsConst[]]} DjsArray */
-/**
- * @typedef {{
-*  readonly [k in string]: DjsConst
-* }} DjsObject
-*/
-/** @typedef {['array', list.List<DjsConst>]} DjsStackArray */
-/** @typedef {['object', map.Map<DjsConst>, string]} DjsStackObject */
-/**
- * @typedef {|
-* DjsStackArray |
-* DjsStackObject
-* } DjsStackElement
-*/
-/** @typedef {list.List<DjsStackElement>} DjsStack */
-/** @typedef {InitialState | NewLineRequiredState | ImportState | ConstState | ExportState | ParseValueState | ResultState | ErrorState} ParserState */
-/**
- * @typedef {{
-*  readonly refs: map.Map<DjsModuleRef>
-*  readonly modules: list.List<string>
-*  readonly consts: list.List<DjsConst>
-* }} ModuleState
-*/
-/**
- * @typedef {{
-*  readonly state: ''
-*  readonly module: ModuleState
-* }} InitialState
-*/
-/**
- * @typedef {{
-*  readonly state: 'nl'
-*  readonly module: ModuleState
-* }} NewLineRequiredState
-*/
-/**
- * @typedef {{
-*  readonly state: 'import' | 'import+name' | 'import+from'
-*  readonly module: ModuleState
-* }} ImportState
-*/
-/**
- * @typedef {{
-*  readonly state: 'const' | 'const+name'
-*  readonly module: ModuleState
-* }} ConstState
-*/
-/**
- * @typedef {{
-*  readonly state: 'export'
-*  readonly module: ModuleState
-* }} ExportState
-*/
-/**
- * @typedef {{
-*  readonly state: 'constValue' | 'exportValue'
-*  readonly module: ModuleState
-*  readonly valueState: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,'
-*  readonly top: DjsStackElement | null
-*  readonly stack: DjsStack
-* }} ParseValueState
-*/
-/**
- * @typedef {{
-*  readonly state: 'result'
-*  readonly module: ModuleState
-* }} ResultState
-*/
-/**
- * @typedef {{
-*  readonly state: 'error'
-*  readonly message: string
-* }} ErrorState
-*/
-/** @type {(token: tokenizerT.DjsToken) => (state: InitialState) => ParserState}} */
-const parseInitialOp = token => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'id': {
-            switch (token.value) {
-                case 'import': return { ...state, state: 'import' };
-                case 'const': return { ...state, state: 'const' };
-                case 'export': return { ...state, state: 'export' };
-            }
-        }
-    }
-    return { state: 'error', message: 'unexpected token' };
-};
-/** @type {(token: tokenizerT.DjsToken) => (state: NewLineRequiredState) => ParserState}} */
-const parseNewLineRequiredOp = token => state => {
-    switch (token.kind) {
-        case 'ws':
-        case '//':
-        case '/*': return state;
-        case 'nl': return { ...state, state: '' };
-        default: return { state: 'error', message: 'unexpected token' };
-    }
-};
-/** @type {(token: tokenizerT.DjsToken) => (state: ExportState) => ParserState}} */
-const parseExportOp = token => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'id': {
-            if (token.value === 'default')
-                return { ...state, state: 'exportValue', valueState: '', top: null, stack: null };
-        }
-    }
-    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':
-        case '//':
-        case '/*': return state;
-        case 'id': {
-            if (map.at(token.value)(state.module.refs) !== null)
-                return { state: 'error', message: 'duplicate id' };
-            /** @type {DjsModuleRef} */
-            let cref = ['cref', length(state.module.consts)];
-            let refs = map.setReplace(token.value)(cref)(state.module.refs);
-            return { ...state, state: 'const+name', module: { ...state.module, refs: refs } };
-        }
-        default: return { state: 'error', message: 'unexpected token' };
-    }
-};
-/** @type {(token: tokenizerT.DjsToken) => (state: ConstState) => ParserState}} */
-const parseConstNameOp = token => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case '=': return { ...state, state: 'constValue', valueState: '', top: null, stack: null };
-        default: return { state: 'error', message: 'unexpected token' };
-    }
-};
-/** @type {(token: tokenizerT.DjsToken) => (state: ImportState) => ParserState}} */
-const parseImportOp = token => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'id': {
-            if (map.at(token.value)(state.module.refs) !== null)
-                return { state: 'error', message: 'duplicate id' };
-            /** @type {DjsModuleRef} */
-            let aref = ['aref', length(state.module.modules)];
-            let refs = map.setReplace(token.value)(aref)(state.module.refs);
-            return { ...state, state: 'import+name', module: { ...state.module, refs: refs } };
-        }
-        default: return { state: 'error', message: 'unexpected token' };
-    }
-};
-/** @type {(token: tokenizerT.DjsToken) => (state: ImportState) => ParserState}} */
-const parseImportNameOp = token => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'id': {
-            if (token.value === 'from')
-                return { ...state, state: 'import+from' };
-        }
-    }
-    return { state: 'error', message: 'unexpected token' };
-};
-/** @type {(token: tokenizerT.DjsToken) => (state: ImportState) => ParserState}} */
-const parseImportFromOp = token => state => {
-    switch (token.kind) {
-        case 'ws':
-        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 } };
-        }
-        default: return { state: 'error', message: 'unexpected token' };
-    }
-};
-/** @type {(obj: DjsStackObject) => (key: string) => DjsStackObject} */
-const addKeyToObject = obj => key => (['object', obj[1], key]);
-/** @type {(obj: DjsStackObject) => (value: DjsConst) => DjsStackObject} */
-const addValueToObject = obj => value => (['object', setReplace(obj[2])(value)(obj[1]), '']);
-/** @type {(array: DjsStackArray) => (value: DjsConst) => DjsStackArray} */
-const addToArray = array => value => (['array', list.concat(array[1])([value])]);
-/** @type {(state: ParseValueState) => (key: string) => ParserState} */
-const pushKey = state => key => {
-    if (state.top?.[0] === 'object') {
-        return { ...state, valueState: '{k', top: addKeyToObject(state.top)(key), stack: state.stack };
-    }
-    return { state: 'error', message: 'error' };
-};
-/** @type {(state: ParseValueState) => (value: DjsConst) => ParserState} */
-const pushValue = state => value => {
-    if (state.top === null) {
-        let consts = list.concat(state.module.consts)([value]);
-        switch (state.state) {
-            case 'exportValue': return { ...state, state: 'result', module: { ...state.module, consts: consts } };
-            case 'constValue': return { ...state, state: 'nl', module: { ...state.module, consts: consts } };
-        }
-    }
-    if (state.top?.[0] === 'array') {
-        return { ...state, valueState: '[v', top: addToArray(state.top)(value), stack: state.stack };
-    }
-    return { ...state, valueState: '{v', top: addValueToObject(state.top)(value), stack: state.stack };
-};
-/** @type {(state: ParseValueState) => (name: string) => ParserState} */
-const pushRef = state => name => {
-    const ref = at(name)(state.module.refs);
-    if (ref === null)
-        return { state: 'error', message: 'const not found' };
-    return pushValue(state)(ref);
-};
-/** @type {(state: ParseValueState) => ParserState} */
-const startArray = state => {
-    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
-    return { ...state, valueState: '[', top: ['array', null], stack: newStack };
-};
-/** @type {(state: ParseValueState) => ParserState} */
-const endArray = state => {
-    const top = state.top;
-    /** @type {ParseValueState} */
-    const newState = { ...state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
-    if (top !== null && top[0] === 'array') {
-        /** @type {DjsArray} */
-        const array = ['array', toArray(top[1])];
-        return pushValue(newState)(array);
-    }
-    return pushValue(newState)(null);
-};
-/** @type {(state: ParseValueState) => ParserState} */
-const startObject = state => {
-    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
-    return { ...state, valueState: '{', top: ['object', null, ''], stack: newStack };
-};
-/** @type {(state: ParseValueState) => ParserState} */
-const endObject = state => {
-    const obj = state?.top !== null && state?.top[0] === 'object' ? fromMap(state.top[1]) : null;
-    /** @type {ParseValueState} */
-    const newState = { ...state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
-    return pushValue(newState)(obj);
-};
-/** @type {(token: tokenizerT.DjsToken) => DjsConst} */
-const tokenToValue = token => {
-    switch (token.kind) {
-        case 'null': return null;
-        case 'false': return false;
-        case 'true': return true;
-        case 'number': return parseFloat(token.value);
-        case 'string': return token.value;
-        case 'bigint': return token.value;
-        case 'undefined': return undefined;
-        default: return null;
-    }
-};
-/** @type {(token: tokenizerT.DjsToken) => boolean} */
-const isValueToken = token => {
-    switch (token.kind) {
-        case 'null':
-        case 'false':
-        case 'true':
-        case 'number':
-        case 'string':
-        case 'bigint':
-        case 'undefined': return true;
-        default: return false;
-    }
-};
-/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
-const parseValueOp = token => state => {
-    if (isValueToken(token)) {
-        return pushValue(state)(tokenToValue(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));
-    }
-    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 => {
-    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 => {
-    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 => {
-    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));
-    }
-    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 => {
-    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 => {
-    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>} */
-const foldOp = token => state => {
-    switch (state.state) {
-        case '': return parseInitialOp(token)(state);
-        case 'nl': return parseNewLineRequiredOp(token)(state);
-        case 'import': return parseImportOp(token)(state);
-        case 'import+name': return parseImportNameOp(token)(state);
-        case 'import+from': return parseImportFromOp(token)(state);
-        case 'const': return parseConstOp(token)(state);
-        case 'const+name': return parseConstNameOp(token)(state);
-        case 'export': return parseExportOp(token)(state);
-        case 'result': return parseResultOp(token)(state);
-        case 'error': return { state: 'error', message: state.message };
-        case 'constValue':
-        case 'exportValue':
-            {
-                switch (state.valueState) {
-                    case '': return parseValueOp(token)(state);
-                    case '[': return parseArrayStartOp(token)(state);
-                    case '[v': return parseArrayValueOp(token)(state);
-                    case '[,': return parseValueOp(token)(state);
-                    case '{': return parseObjectStartOp(token)(state);
-                    case '{k': return parseObjectKeyOp(token)(state);
-                    case '{:': return parseObjectColonOp(token)(state);
-                    case '{v': return parseObjectNextOp(token)(state);
-                    case '{,': return parseObjectCommaOp(token)(state);
-                }
-            }
-    }
-};
-/** @type {(tokenList: list.List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>} */
-export const parse = tokenList => {
-    const state = fold(foldOp)({ state: '', module: { refs: null, modules: null, consts: null } })(tokenList);
-    switch (state.state) {
-        case 'result': return result.ok([toArray(state.module.modules), toArray(state.module.consts)]);
-        case 'error': return result.error(state.message);
-        default: return result.error('unexpected end');
-    }
-};

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

@@ -1,13 +0,0 @@
-declare namespace _default {
-    let valid: (() => void)[];
-    let invalid: (() => void)[];
-    let validWhiteSpaces: (() => void)[];
-    let validModule: (() => void)[];
-    let invalidModule: (() => void)[];
-    let validWithConst: (() => void)[];
-    let invalidWithConst: (() => void)[];
-    let validWithArgs: (() => void)[];
-    let invalidWithArgs: (() => void)[];
-    let comments: (() => void)[];
-}
-export default _default;