astn 0.105.0 → 0.110.0

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

@@ -1,15 +0,0 @@
-import * as astn from "../../interface";
-import * as etc from "../../../etc/interface";
-import * as tokenLevel from "../../../tokenLevel/interface";
-import { TokenizerOptions } from "./TokenizerOptions";
-import { IPreTokenStreamConsumer } from "./IPreTokenStreamConsumer";
-/**
- *
- * @param tokenStreamConsumer
- * @param onError
- * @param opt
- */
-export declare function createStreamPreTokenizer(tokenStreamConsumer: IPreTokenStreamConsumer, onError: ($: {
-    error: astn.TokenError;
-    range: tokenLevel.Range;
-}) => void, opt?: TokenizerOptions): etc.IStreamConsumer<string, null>;

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

@@ -1,175 +0,0 @@
-"use strict";
-/* eslint
-    complexity:"off",
-    no-console:"off",
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStreamPreTokenizer = void 0;
-const createPreTokenizer_1 = require("./createPreTokenizer");
-const Whitespace = {
-    tab: 0x09,
-    lineFeed: 0x0A,
-    carriageReturn: 0x0D,
-    space: 0x20, //
-};
-/**
- *
- * @param tokenStreamConsumer
- * @param onError
- * @param opt
- */
-function createStreamPreTokenizer(tokenStreamConsumer, onError, opt) {
-    const location = {
-        position: -1,
-        column: 0,
-        line: 1,
-    };
-    const spacesPerTab = opt === undefined
-        ? 4
-        : opt.spaces_per_tab === undefined
-            ? 4
-            : opt.spaces_per_tab;
-    const locationState = {
-        getCurrentLocation: () => {
-            return {
-                position: location.position + 1,
-                line: location.line,
-                column: location.column + 1,
-            };
-        },
-        getNextLocation: () => {
-            return {
-                position: location.position + 2,
-                line: location.line,
-                column: location.column + 2,
-            };
-        },
-        increase: (character) => {
-            location.position++;
-            //set the position
-            switch (character) {
-                case Whitespace.lineFeed:
-                    location.line++;
-                    location.column = 0;
-                    break;
-                case Whitespace.carriageReturn:
-                    break;
-                case Whitespace.tab:
-                    location.column += spacesPerTab;
-                    break;
-                default:
-                    location.column++;
-            }
-        },
-    };
-    const tokenizerState = (0, createPreTokenizer_1.createPreTokenizer)(locationState, onError);
-    return {
-        onData: (chunk) => {
-            let currentIndex = 0;
-            const str = chunk;
-            const currentChunk = {
-                lookahead: () => {
-                    const char = str.charCodeAt(currentIndex);
-                    return isNaN(char) ? null : char;
-                },
-                increaseIndex: () => {
-                    currentIndex += 1;
-                },
-                getCurrentIndex: () => {
-                    return currentIndex;
-                },
-                getString: () => {
-                    return str;
-                },
-            };
-            while (true) {
-                const la = currentChunk.lookahead();
-                if (la === null) {
-                    return;
-                }
-                function createLoopState(chunk2) {
-                    let startIndex = null;
-                    function ensureFlushed(callback) {
-                        if (startIndex !== null) {
-                            return {
-                                startSnippet: false,
-                                consumeCharacter: false,
-                                preToken: {
-                                    type: ["snippet", {
-                                            chunk: chunk2.getString(),
-                                            begin: startIndex,
-                                            end: chunk2.getCurrentIndex(),
-                                        }],
-                                },
-                            };
-                        }
-                        return callback();
-                    }
-                    return {
-                        /**
-                         * if not flushed, the callback is not called.
-                         * the current character position should not change so that the next round
-                         * the same call will be made, but now it is flushed, so the callback will be called
-                         */
-                        ensureFlushed: (callback) => {
-                            return ensureFlushed(callback);
-                        },
-                        whileLoop: (callback) => {
-                            function whileLoop(callback2) {
-                                while (true) {
-                                    const returnValue = callback2();
-                                    if (returnValue !== undefined) {
-                                        return returnValue;
-                                    }
-                                }
-                            }
-                            return whileLoop(() => {
-                                const nextChar = chunk2.lookahead();
-                                if (nextChar === null) {
-                                    return ensureFlushed(() => {
-                                        return {
-                                            startSnippet: false,
-                                            consumeCharacter: false,
-                                            preToken: null,
-                                        };
-                                    }).preToken;
-                                }
-                                const result = callback(nextChar);
-                                if (result.startSnippet) {
-                                    if (startIndex === null) {
-                                        startIndex = chunk2.getCurrentIndex();
-                                    }
-                                }
-                                if (result.consumeCharacter) {
-                                    const cc = chunk2.lookahead();
-                                    if (cc === null) {
-                                        throw new Error("Unexpected consume");
-                                    }
-                                    locationState.increase(cc);
-                                    chunk2.increaseIndex();
-                                }
-                                if (result.preToken !== null) {
-                                    return result.preToken;
-                                }
-                                return undefined;
-                            });
-                        },
-                    };
-                }
-                const loopState = createLoopState(currentChunk);
-                const tokenData = tokenizerState.createNextToken(loopState);
-                if (tokenData !== null) {
-                    tokenStreamConsumer.onData(tokenData);
-                }
-            }
-        },
-        onEnd: () => {
-            const tokenData = tokenizerState.handleDanglingToken();
-            if (tokenData !== null) {
-                tokenStreamConsumer.onData(tokenData);
-            }
-            tokenStreamConsumer.onEnd(locationState.getCurrentLocation());
-        },
-    };
-}
-exports.createStreamPreTokenizer = createStreamPreTokenizer;

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

@@ -1,6 +0,0 @@
-import * as astn from "../../interface";
-import * as grammar from "../../../grammar/interface";
-export declare function createStructureParser<EventAnnotation>($p: {
-    handler: grammar.IStructureHandler<EventAnnotation>;
-    onError: astn.IStructureErrorHandler<EventAnnotation>;
-}): grammar.IStructureParser<EventAnnotation>;

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

@@ -1,214 +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.createStructureParser = void 0;
-const pr = __importStar(require("pareto-runtime"));
-const createTreeParser_1 = require("./createTreeParser");
-function createStructureParser($p) {
-    const rootContext = { state: ["expecting header or body", {}] };
-    return {
-        onEnd: (annotation) => {
-            function raiseError(error) {
-                $p.onError({
-                    error: ["structure", error],
-                    annotation: annotation,
-                });
-            }
-            switch (rootContext.state[0]) {
-                case "expecting header or body": {
-                    //const $ = rootContext.state[1]
-                    raiseError(["expected the schema start (!) or root value", {}]);
-                    break;
-                }
-                case "expecting schema reference or embedded schema": {
-                    raiseError(["expected a schema reference or an embedded schema", {}]);
-                    break;
-                }
-                case "expecting schema schema reference": {
-                    raiseError(["expected a schema schema reference", {}]);
-                    break;
-                }
-                case "processing embedded schema": {
-                    const $$ = rootContext.state[1];
-                    $$.schemaParser.onEnd(annotation);
-                    break;
-                }
-                case "processing body": {
-                    const $ = rootContext.state[1];
-                    $.bodyParser.onEnd(annotation);
-                    break;
-                }
-                default:
-                    pr.au(rootContext.state[0]);
-            }
-        },
-        onToken: ($) => {
-            const data = $;
-            function raiseError(error) {
-                $p.onError({
-                    error: ["structure", error],
-                    annotation: $.annotation,
-                });
-            }
-            switch (rootContext.state[0]) {
-                case "expecting header or body": {
-                    switch ($.token[0]) {
-                        case "header start": {
-                            rootContext.state = ["expecting schema reference or embedded schema", {
-                                    headerAnnotation: $.annotation,
-                                }];
-                            break;
-                        }
-                        case "content": {
-                            pr.cc($.token[1], ($) => {
-                                $p.handler.onNoInternalSchema({});
-                                const bp = $p.handler.onBody();
-                                rootContext.state = ["processing body", {
-                                        bodyParser: bp,
-                                    }];
-                                bp.onToken({
-                                    annotation: data.annotation,
-                                    token: $,
-                                });
-                            });
-                            break;
-                        }
-                        default:
-                            pr.au($.token[0]);
-                    }
-                    break;
-                }
-                case "expecting schema reference or embedded schema": {
-                    const headerAnnotation = rootContext.state[1].headerAnnotation;
-                    switch ($.token[0]) {
-                        case "header start": {
-                            rootContext.state = ["expecting schema schema reference", {
-                                    headerAnnotation: headerAnnotation,
-                                    embeddedSchemaAnnotation: $.annotation,
-                                }];
-                            break;
-                        }
-                        case "content": {
-                            pr.cc($.token[1], ($) => {
-                                switch ($[0]) {
-                                    case "structural": {
-                                        pr.cc($[1], ($) => {
-                                            raiseError(["expected a schema reference or an embedded schema", {}]);
-                                        });
-                                        break;
-                                    }
-                                    case "simple string": {
-                                        pr.cc($[1], ($) => {
-                                            $p.handler.onSchemaReference({
-                                                headerAnnotation: headerAnnotation,
-                                                token: {
-                                                    token: $,
-                                                    annotation: data.annotation,
-                                                },
-                                            });
-                                            rootContext.state = ["processing body", {
-                                                    bodyParser: $p.handler.onBody(),
-                                                }];
-                                        });
-                                        break;
-                                    }
-                                    case "multiline string": {
-                                        pr.cc($[1], ($) => {
-                                            raiseError(["expected an embedded schema", {}]);
-                                        });
-                                        break;
-                                    }
-                                    default:
-                                        pr.au($[0]);
-                                }
-                            });
-                            break;
-                        }
-                        default:
-                            pr.au($.token[0]);
-                    }
-                    break;
-                }
-                case "expecting schema schema reference": {
-                    const headerAnnotation = rootContext.state[1].headerAnnotation;
-                    const embeddedSchemaAnnotation = rootContext.state[1].embeddedSchemaAnnotation;
-                    if ($.token[0] !== "content" || $.token[1][0] !== "simple string") {
-                        raiseError(["expected a schema schema reference", {}]);
-                    }
-                    else {
-                        const x = $p.handler.onEmbeddedSchema({
-                            headerAnnotation: headerAnnotation,
-                            embeddedSchemaAnnotation: embeddedSchemaAnnotation,
-                            schemaSchemaReferenceToken: {
-                                token: $.token[1][1],
-                                annotation: $.annotation,
-                            },
-                        });
-                        rootContext.state = ["processing embedded schema", {
-                                schemaParser: (0, createTreeParser_1.createTreeParser)({
-                                    handler: {
-                                        onEnd: ($) => {
-                                            x.onEnd($);
-                                            rootContext.state = ["processing body", {
-                                                    bodyParser: $p.handler.onBody(),
-                                                }];
-                                        },
-                                        root: x.root,
-                                    },
-                                    onError: $p.onError,
-                                }),
-                            }];
-                    }
-                    break;
-                }
-                case "processing embedded schema": {
-                    const $ = rootContext.state[1];
-                    if (data.token[0] !== "content") {
-                        throw new Error("IMPLEMENT ME");
-                    }
-                    $.schemaParser.onToken({
-                        annotation: data.annotation,
-                        token: data.token[1],
-                    });
-                    break;
-                }
-                case "processing body": {
-                    if (data.token[0] !== "content") {
-                        throw new Error("IMPLEMENT ME");
-                    }
-                    const $ = rootContext.state[1];
-                    $.bodyParser.onToken({
-                        annotation: data.annotation,
-                        token: data.token[1],
-                    });
-                    break;
-                }
-                default:
-                    pr.au(rootContext.state[0]);
-            }
-        },
-    };
-}
-exports.createStructureParser = createStructureParser;

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

@@ -1,11 +0,0 @@
-import * as astn from "../../interface";
-import * as etc from "../../../etc/interface";
-import * as grammar from "../../../grammar/interface";
-import * as tokenLevel from "../../../tokenLevel/interface";
-export declare function createTokenizer($p: {
-    parser: grammar.IStructureParser<tokenLevel.TokenizerAnnotationData>;
-    onError: ($: {
-        error: astn.TokenizerError;
-        range: tokenLevel.Range;
-    }) => void;
-}): etc.IStreamConsumer<string, null>;

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

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTokenizer = void 0;
-const createStreamPreTokenizer_1 = require("./createStreamPreTokenizer");
-const createTokenizer2_1 = require("./createTokenizer2");
-function createTokenizer($p) {
-    return (0, createStreamPreTokenizer_1.createStreamPreTokenizer)((0, createTokenizer2_1.createTokenizer2)($p.parser, ($) => {
-        $p.onError({
-            error: ["tokenizer", $.error],
-            range: $.range,
-        });
-    }), ($) => {
-        $p.onError({
-            error: ["pre", $.error],
-            range: $.range,
-        });
-    });
-}
-exports.createTokenizer = createTokenizer;

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

@@ -1,9 +0,0 @@
-import * as astn from "../../interface";
-import * as grammar from "../../../grammar/interface";
-import * as tokenLevel from "../../../tokenLevel/interface";
-import { IPreTokenStreamConsumer } from "./IPreTokenStreamConsumer";
-export declare function printTokenizer2Error(error: astn.Tokenizer2Error): string;
-export declare function createTokenizer2(parser: grammar.IStructureParser<tokenLevel.TokenizerAnnotationData>, onError2: ($: {
-    error: astn.Tokenizer2Error;
-    range: tokenLevel.Range;
-}) => void): IPreTokenStreamConsumer;