astn 0.105.0 → 0.110.0

package/dist/modules/astn/esc/implementation/createTreeParser.js

@@ -1,537 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTreeParser = void 0;
-/* eslint
-    no-underscore-dangle: "off",
-    complexity: off,
-*/
-const pr = __importStar(require("pareto-runtime"));
-function createTreeParser($p) {
-    let done = false;
-    const currentTreeHandlers = [];
-    if ($p.handler !== null) {
-        currentTreeHandlers.push($p.handler);
-    }
-    function createTreeParserImp() {
-        function raiseError(error, annotation) {
-            $p.onError({
-                error: ["tree", error],
-                annotation: annotation,
-            });
-        }
-        let state = null;
-        function closeObjectImp($, annotation, processing) {
-            pop(annotation, processing);
-        }
-        function closeArrayImp($, annotation, processing) {
-            pop(annotation, processing);
-        }
-        function forceTaggedUnionClose(context, annotation, processing) {
-            if (context.state[0] === "expecting value") {
-                context.state[1].forEach(($) => {
-                    $.missing();
-                });
-                raiseError(["missing tagged union value", {}], annotation);
-            }
-            else {
-                context.handlers.forEach(($) => {
-                    $.missingOption();
-                });
-                raiseError(["missing tagged union option and value", {}], annotation);
-            }
-            closeTaggedUnionImp(annotation, processing);
-        }
-        function closeTaggedUnionImp(annotation, processing) {
-            pop(annotation, processing);
-        }
-        function pop(annotation, processing) {
-            const previousContext = processing.stack.pop();
-            if (previousContext === undefined) {
-                //raiseError(["unexpected end of text", { "still in": [stillin] }], annotation)
-                state = null;
-            }
-            else {
-                if (previousContext[0] === "taggedunion") {
-                    const taggedUnion = previousContext[1];
-                    if (taggedUnion.state[0] !== "expecting value") {
-                        raiseError(["missing option", {}], annotation);
-                    }
-                    else {
-                        taggedUnion.handlers.forEach(($) => {
-                            $.end({
-                                annotation: null,
-                            });
-                        });
-                    }
-                }
-                processing.currentContext = previousContext;
-            }
-            wrapupValue(annotation);
-        }
-        function push(newContext) {
-            if (state === null) {
-                state = {
-                    currentContext: newContext,
-                    stack: [],
-                };
-            }
-            else {
-                state.stack.push(state.currentContext);
-                state.currentContext = newContext;
-            }
-        }
-        function wrapupValue(annotation) {
-            if (state === null) {
-                done = true;
-                currentTreeHandlers.forEach(($) => {
-                    $.onEnd(annotation);
-                });
-            }
-            else {
-                switch (state.currentContext[0]) {
-                    case "array": {
-                        break;
-                    }
-                    case "object": {
-                        state.currentContext[1].propertyHandlers = null;
-                        break;
-                    }
-                    case "taggedunion": {
-                        if (state.currentContext[1].state[0] !== "expecting value") {
-                            pr.logError("HANDLE UNEXPECTED TAGGED UNION VALUE END");
-                        }
-                        closeTaggedUnionImp(annotation, state);
-                        break;
-                    }
-                    default:
-                        return pr.au(state.currentContext[0]);
-                }
-            }
-        }
-        function getValueHandler(annotation) {
-            if (state === null) {
-                if (done) {
-                    raiseError(["unexpected data after end", {}], annotation);
-                    return [];
-                }
-                return currentTreeHandlers.map(($) => {
-                    return $.root.exists;
-                });
-            }
-            else {
-                switch (state.currentContext[0]) {
-                    case "array": {
-                        const $ = state.currentContext[1];
-                        $.foundElements = true;
-                        return state.currentContext[1].arrayHandlers.map(($) => {
-                            return $.element({
-                                annotation: null,
-                            });
-                        });
-                    }
-                    case "object": {
-                        if (state.currentContext[1].propertyHandlers === null) {
-                            raiseError(["missing key", {}], annotation);
-                            return [];
-                        }
-                        else {
-                            return state.currentContext[1].propertyHandlers.map(($) => {
-                                return $.exists;
-                            });
-                        }
-                    }
-                    case "taggedunion": {
-                        if (state.currentContext[1].state[0] !== "expecting value") {
-                            raiseError(["missing option", {}], annotation);
-                            return [];
-                        }
-                        else {
-                            return state.currentContext[1].state[1].map(($) => {
-                                return $.exists;
-                            });
-                        }
-                    }
-                    default:
-                        return pr.au(state.currentContext[0]);
-                }
-            }
-        }
-        return {
-            forceEnd: (endAnnotation) => {
-                unwindLoop: while (true) {
-                    if (state === null) {
-                        if (currentTreeHandlers !== null) {
-                            currentTreeHandlers.forEach(($) => {
-                                $.root.missing();
-                            });
-                            done = true;
-                        }
-                        break unwindLoop;
-                    }
-                    switch (state.currentContext[0]) {
-                        case "array": {
-                            const $ = state.currentContext[1];
-                            raiseError(["unexpected end of text", { "still in": ["array", {}] }], endAnnotation);
-                            closeArrayImp($, endAnnotation, state);
-                            break;
-                        }
-                        case "object": {
-                            const $ = state.currentContext[1];
-                            if ($.propertyHandlers !== null) {
-                                $.propertyHandlers.forEach(($) => {
-                                    $.missing();
-                                });
-                                $.propertyHandlers = null;
-                            }
-                            raiseError(["unexpected end of text", { "still in": ["object", {}] }], endAnnotation);
-                            closeObjectImp($, endAnnotation, state);
-                            break;
-                        }
-                        case "taggedunion": {
-                            const $ = state.currentContext[1];
-                            switch ($.state[0]) {
-                                case "expecting option": {
-                                    //const $$ = $.state[1]
-                                    $.handlers.forEach(($) => {
-                                        $.missingOption();
-                                    });
-                                    break;
-                                }
-                                case "expecting value": {
-                                    const $$ = $.state[1];
-                                    //option not yet parsed
-                                    $$.forEach(($) => {
-                                        $.missing();
-                                    });
-                                    break;
-                                }
-                                default:
-                                    pr.au($.state[0]);
-                            }
-                            raiseError(["unexpected end of text", { "still in": ["tagged union", {}] }], endAnnotation);
-                            closeTaggedUnionImp(endAnnotation, state);
-                            break;
-                        }
-                        default:
-                            pr.au(state.currentContext[0]);
-                    }
-                }
-            },
-            taggedUnion: ($$) => {
-                if (state === null) {
-                    state = {
-                        stack: [],
-                        currentContext: ["taggedunion", {
-                                handlers: getValueHandler($$.annotation).map(($) => {
-                                    return $.taggedUnion({
-                                        token: $$,
-                                    });
-                                }),
-                                state: ["expecting option", {}],
-                            }],
-                    };
-                }
-                else {
-                    push(["taggedunion", {
-                            handlers: getValueHandler($$.annotation).map(($) => {
-                                return $.taggedUnion({
-                                    token: $$,
-                                });
-                            }),
-                            state: ["expecting option", {}],
-                        }]);
-                }
-            },
-            multilineString: ($$) => {
-                getValueHandler($$.annotation).forEach(($) => {
-                    $.multilineString({
-                        token: $$,
-                    });
-                });
-                wrapupValue($$.annotation);
-            },
-            simpleString: ($$$) => {
-                function onStringValue() {
-                    getValueHandler($$$.annotation).forEach(($) => {
-                        $.simpleString({
-                            token: $$$,
-                        });
-                    });
-                    wrapupValue($$$.annotation);
-                }
-                if (state === null) {
-                    onStringValue();
-                }
-                else {
-                    switch (state.currentContext[0]) {
-                        case "array": {
-                            onStringValue();
-                            break;
-                        }
-                        case "object": {
-                            const $$ = state.currentContext[1];
-                            if ($$.propertyHandlers === null) {
-                                $$.propertyHandlers = $$.objectHandlers.map(($) => {
-                                    return $.property({
-                                        token: $$$,
-                                    });
-                                });
-                                break;
-                            }
-                            else {
-                                onStringValue();
-                                break;
-                            }
-                        }
-                        case "taggedunion": {
-                            const $$ = state.currentContext[1];
-                            switch ($$.state[0]) {
-                                case "expecting option": {
-                                    $$.state = ["expecting value", $$.handlers.map(($) => {
-                                            return $.option({
-                                                token: $$$,
-                                            });
-                                        })];
-                                    break;
-                                }
-                                case "expecting value": {
-                                    onStringValue();
-                                    break;
-                                }
-                                default:
-                                    pr.au($$.state[0]);
-                            }
-                            break;
-                        }
-                        default:
-                            pr.au(state.currentContext[0]);
-                    }
-                }
-            },
-            openObject: ($$) => {
-                push(["object", {
-                        type: $$.token.type[0] === "verbose group" ? ["verbose group", {}] : ["dictionary", {}],
-                        objectHandlers: getValueHandler($$.annotation).map(($) => {
-                            return $.object({
-                                token: $$,
-                            });
-                        }),
-                        propertyHandlers: null,
-                    }]);
-            },
-            openArray: ($$) => {
-                push(["array", {
-                        foundElements: false,
-                        type: $$.token.type[0] === "shorthand group" ? ["shorthand group", {}] : ["list", {}],
-                        arrayHandlers: getValueHandler($$.annotation).map(($) => {
-                            return $.array({
-                                token: $$,
-                            });
-                        }),
-                    }]);
-            },
-            closeObject: ($$) => {
-                unwindLoop: while (true) {
-                    if (state === null) {
-                        break unwindLoop;
-                    }
-                    switch (state.currentContext[0]) {
-                        case "array": {
-                            const $ = state.currentContext[1];
-                            raiseError(["missing array close", {}], $$.annotation);
-                            closeArrayImp($, $$.annotation, state);
-                            break;
-                        }
-                        case "object": {
-                            break unwindLoop;
-                            break;
-                        }
-                        case "taggedunion": {
-                            const $ = state.currentContext[1];
-                            forceTaggedUnionClose($, $$.annotation, state);
-                            break;
-                        }
-                        default:
-                            pr.au(state.currentContext[0]);
-                    }
-                }
-                if (state === null || state.currentContext[0] !== "object") {
-                    raiseError(["unexpected end of object", {}], $$.annotation);
-                }
-                else {
-                    const $$$ = state.currentContext[1];
-                    if ($$$.propertyHandlers !== null) {
-                        //was in the middle of processing a property
-                        //the key was parsed, but the data was not
-                        raiseError(["missing property value", {}], $$.annotation);
-                        $$$.propertyHandlers.forEach(($) => {
-                            $.missing();
-                        });
-                        $$$.propertyHandlers = null;
-                    }
-                    $$$.objectHandlers.forEach(($) => {
-                        $.onEnd({
-                            token: $$,
-                        });
-                    });
-                    closeObjectImp($$$, $$.annotation, state);
-                }
-            },
-            closeArray: ($$) => {
-                unwindLoop: while (true) {
-                    if (state === null) {
-                        break unwindLoop;
-                    }
-                    switch (state.currentContext[0]) {
-                        case "array": {
-                            break unwindLoop;
-                            break;
-                        }
-                        case "object": {
-                            const $$2 = state.currentContext[1];
-                            raiseError(["missing object close", {}], $$.annotation);
-                            closeObjectImp($$2, $$.annotation, state);
-                            break;
-                        }
-                        case "taggedunion": {
-                            forceTaggedUnionClose(state.currentContext[1], $$.annotation, state);
-                            break;
-                        }
-                        default:
-                            pr.au(state.currentContext[0]);
-                    }
-                }
-                if (state === null || state.currentContext[0] !== "array") {
-                    raiseError(["unexpected end of array", {}], $$.annotation);
-                }
-                else {
-                    const $$$ = state.currentContext[1];
-                    switch ($$$.type[0]) {
-                        case "list": {
-                            break;
-                        }
-                        case "shorthand group": {
-                            break;
-                        }
-                        default:
-                            pr.au($$$.type[0]);
-                    }
-                    $$$.arrayHandlers.forEach(($) => {
-                        $.onEnd({
-                            token: $$,
-                        });
-                    });
-                    closeArrayImp($$$, $$.annotation, state);
-                }
-            },
-        };
-    }
-    const parser = createTreeParserImp();
-    return {
-        onToken: (token) => {
-            switch (token.token[0]) {
-                case "structural": {
-                    const punctuation = token.token[1];
-                    function createToken(dta) {
-                        return {
-                            token: dta,
-                            annotation: token.annotation,
-                        };
-                    }
-                    switch (punctuation.type[0]) {
-                        case "close shorthand group":
-                            parser.closeArray(createToken({}));
-                            break;
-                        case "close list":
-                            parser.closeArray(createToken({}));
-                            break;
-                        case "open shorthand group":
-                            parser.openArray(createToken({
-                                type: ["shorthand group", {}],
-                            }));
-                            break;
-                        case "open list":
-                            parser.openArray(createToken({
-                                type: ["list", {}],
-                            }));
-                            break;
-                        case "close dictionary":
-                            parser.closeObject(createToken({}));
-                            break;
-                        case "close verbose group":
-                            parser.closeObject(createToken({}));
-                            break;
-                        case "open dictionary":
-                            parser.openObject(createToken({
-                                type: ["dictionary", {}],
-                            }));
-                            break;
-                        case "open verbose group":
-                            parser.openObject(createToken({
-                                type: ["verbose group", {}],
-                            }));
-                            break;
-                        case "tagged union start":
-                            parser.taggedUnion(createToken({}));
-                            break;
-                        default:
-                            pr.au(punctuation.type[0]);
-                    }
-                    break;
-                }
-                case "simple string": {
-                    pr.cc(token.token[1], ($) => {
-                        parser.simpleString({
-                            annotation: token.annotation,
-                            token: {
-                                value: $.value,
-                                wrapping: $.wrapping,
-                            },
-                        });
-                    });
-                    break;
-                }
-                case "multiline string": {
-                    pr.cc(token.token[1], ($) => {
-                        parser.multilineString({
-                            annotation: token.annotation,
-                            token: {
-                                lines: $.lines,
-                            },
-                        });
-                    });
-                    break;
-                }
-                default:
-                    pr.au(token.token[0]);
-            }
-        },
-        onEnd: (annotation) => {
-            parser.forceEnd(annotation);
-        },
-    };
-}
-exports.createTreeParser = createTreeParser;

package/dist/modules/astn/esc/implementation/dummyHandlers.d.ts

@@ -1,7 +0,0 @@
-import * as grammar from "../../../grammar/interface";
-export declare function createDummyRequiredValueHandler<EventAnnotation>(): grammar.IRequiredValueHandler<EventAnnotation>;
-export declare function createDummyValueHandler<EventAnnotation>(): grammar.IValueHandler<EventAnnotation>;
-export declare function createDummyTaggedUnionHandler<EventAnnotation>(): grammar.ITaggedUnionHandler<EventAnnotation>;
-export declare function createDummyArrayHandler<EventAnnotation>(): grammar.IArrayHandler<EventAnnotation>;
-export declare function createDummyObjectHandler<EventAnnotation>(): grammar.IObjectHandler<EventAnnotation>;
-export declare function createDummyTreeHandler<EventAnnotation>(): grammar.ITreeHandler<EventAnnotation>;

package/dist/modules/astn/esc/implementation/dummyHandlers.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDummyTreeHandler = exports.createDummyObjectHandler = exports.createDummyArrayHandler = exports.createDummyTaggedUnionHandler = exports.createDummyValueHandler = exports.createDummyRequiredValueHandler = void 0;
-function createDummyRequiredValueHandler() {
-    return {
-        exists: createDummyValueHandler(),
-        missing: () => { },
-    };
-}
-exports.createDummyRequiredValueHandler = createDummyRequiredValueHandler;
-function createDummyValueHandler() {
-    return {
-        array: () => createDummyArrayHandler(),
-        object: () => createDummyObjectHandler(),
-        simpleString: () => { },
-        multilineString: () => { },
-        taggedUnion: () => createDummyTaggedUnionHandler(),
-    };
-}
-exports.createDummyValueHandler = createDummyValueHandler;
-function createDummyTaggedUnionHandler() {
-    return {
-        option: () => createDummyRequiredValueHandler(),
-        missingOption: () => { },
-        end: () => { },
-    };
-}
-exports.createDummyTaggedUnionHandler = createDummyTaggedUnionHandler;
-function createDummyArrayHandler() {
-    return {
-        element: () => createDummyValueHandler(),
-        onEnd: () => { },
-    };
-}
-exports.createDummyArrayHandler = createDummyArrayHandler;
-function createDummyObjectHandler() {
-    return {
-        property: () => {
-            return createDummyRequiredValueHandler();
-        },
-        onEnd: () => { },
-    };
-}
-exports.createDummyObjectHandler = createDummyObjectHandler;
-function createDummyTreeHandler() {
-    return {
-        root: createDummyRequiredValueHandler(),
-        onEnd: () => { },
-    };
-}
-exports.createDummyTreeHandler = createDummyTreeHandler;

package/dist/modules/astn/esc/implementation/expect2.d.ts

@@ -1,23 +0,0 @@
-import * as astn from "../../interface";
-import * as grammar from "../../../grammar/interface";
-export declare type ValueType<EventAnnotation> = [
-    "dicionary",
-    astn.ExpectDictionaryParameters<EventAnnotation>
-] | [
-    "list",
-    astn.ExpectListParameters<EventAnnotation>
-] | [
-    "quoted string",
-    astn.ExpectQuotedStringParameters<EventAnnotation>
-] | [
-    "simple string",
-    astn.ExpectStringParameters<EventAnnotation>
-] | [
-    "tagged union",
-    astn.ExpectTaggedUnionParameters<EventAnnotation>
-] | [
-    "verbose group",
-    astn.ExpectVerboseGroupParameters<EventAnnotation>
-];
-export declare function createRequiredValueHandler<EventAnnotation>(context: astn.IExpectContext<EventAnnotation>, valueType: ValueType<EventAnnotation>, onMissing?: () => void): grammar.IRequiredValueHandler<EventAnnotation>;
-export declare function createValueHandler<EventAnnotation>(context: astn.IExpectContext<EventAnnotation>, valueType: ValueType<EventAnnotation>): grammar.IValueHandler<EventAnnotation>;

package/dist/modules/astn/esc/implementation/expect2.js

@@ -1,65 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createValueHandler = exports.createRequiredValueHandler = void 0;
-const pr = __importStar(require("pareto-runtime"));
-function createRequiredValueHandler(context, valueType, onMissing) {
-    return {
-        exists: createValueHandler(context, valueType),
-        missing: onMissing !== undefined ? onMissing : () => { },
-    };
-}
-exports.createRequiredValueHandler = createRequiredValueHandler;
-function createValueHandler(context, valueType) {
-    switch (valueType[0]) {
-        case "dicionary": {
-            const $1 = valueType[1];
-            return context.expectDictionary($1);
-        }
-        case "list": {
-            const $1 = valueType[1];
-            return context.expectList($1);
-        }
-        case "quoted string": {
-            const $1 = valueType[1];
-            return context.expectQuotedString($1);
-        }
-        case "simple string": {
-            const $1 = valueType[1];
-            return context.expectSimpleString($1);
-        }
-        case "tagged union": {
-            const $1 = valueType[1];
-            return context.expectTaggedUnion($1);
-        }
-        case "verbose group": {
-            const $1 = valueType[1];
-            return context.expectVerboseGroup($1);
-        }
-        default:
-            return pr.au(valueType[0]);
-    }
-}
-exports.createValueHandler = createValueHandler;

package/dist/modules/astn/esc/implementation/getEndLocationFromRange.d.ts

@@ -1,2 +0,0 @@
-import * as tokenLevel from "../../../tokenLevel/interface";
-export declare function getEndLocationFromRange(range: tokenLevel.Range): tokenLevel.Location;