@the_dissidents/libemmm 0.0.5 → 0.0.8

package/dist/src/parser.js

@@ -1,652 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = parse;
-const debug_1 = require("./debug");
-const debug_print_1 = require("./debug-print");
-const interface_1 = require("./interface");
-const messages_1 = require("./messages");
-const parser_config_1 = require("./parser-config");
-const util_1 = require("./util");
-const GROUP_BEGIN = ':--';
-const GROUP_END = '--:';
-const MODIFIER_BLOCK_OPEN = '[.';
-const MODIFIER_CLOSE_SIGN = ']';
-const MODIFIER_END_SIGN = ';';
-const MODIFIER_INLINE_OPEN = '[/';
-const MODIFIER_INLINE_END_TAG = '[;]';
-const MODIFIER_SYSTEM_OPEN = '[-';
-const UnknownModifier = {
-    [interface_1.NodeType.BlockModifier]: new interface_1.BlockModifierDefinition('UNKNOWN', interface_1.ModifierSlotType.Normal),
-    [interface_1.NodeType.InlineModifier]: new interface_1.InlineModifierDefinition('UNKNOWN', interface_1.ModifierSlotType.Normal),
-    [interface_1.NodeType.SystemModifier]: new interface_1.SystemModifierDefinition('UNKNOWN', interface_1.ModifierSlotType.Normal)
-};
-class EmitEnvironment {
-    scanner;
-    root;
-    messages = [];
-    blockStack = [];
-    inlineStack = [];
-    constructor(scanner) {
-        this.scanner = scanner;
-        this.root = { type: interface_1.NodeType.Root, source: scanner.source, content: [] };
-    }
-    message(...m) {
-        for (let msg of m) {
-            this.messages.push(msg);
-            debug_1.debug.trace('issued msg', msg.code, msg.info);
-        }
-    }
-    addBlockNode(n) {
-        (this.blockStack.at(-1) ?? this.root).content.push(n);
-        return n;
-    }
-    addInlineNode(n) {
-        (0, util_1.assert)(this.inlineStack.length > 0);
-        this.inlineStack.at(-1).content.push(n);
-        return n;
-    }
-    addString(str) {
-        (0, util_1.assert)(this.inlineStack.length > 0);
-        const content = this.inlineStack.at(-1).content;
-        const last = content.at(-1);
-        if (last?.type == interface_1.NodeType.Text) {
-            last.content += str;
-            last.location.end = this.scanner.position();
-        }
-        else
-            content.push({
-                type: interface_1.NodeType.Text,
-                location: {
-                    source: this.scanner.source,
-                    start: this.scanner.position() - str.length,
-                    end: this.scanner.position(),
-                },
-                content: str
-            });
-    }
-    startBlock(block) {
-        this.addBlockNode(block);
-        this.blockStack.push(block);
-    }
-    endBlock() {
-        (0, util_1.assert)(this.blockStack.length > 0);
-        const node = this.blockStack.pop();
-        node.location.end = this.scanner.position();
-    }
-    startInline(n) {
-        if (n.type == interface_1.NodeType.Paragraph)
-            this.addBlockNode(n);
-        else
-            this.addInlineNode(n);
-        this.inlineStack.push(n);
-    }
-    endInline() {
-        (0, util_1.assert)(this.inlineStack.length > 0);
-        const node = this.inlineStack.pop();
-        node.location.end = this.scanner.position();
-    }
-}
-class Parser {
-    scanner;
-    cxt;
-    emit;
-    delayDepth = 0;
-    groupDepth = 0;
-    constructor(scanner, cxt) {
-        this.scanner = scanner;
-        this.cxt = cxt;
-        this.emit = new EmitEnvironment(scanner);
-    }
-    #loc(to) {
-        return {
-            source: this.scanner.source,
-            start: this.scanner.position(),
-            end: to ?? this.scanner.position()
-        };
-    }
-    #locFrom(from, to) {
-        return {
-            source: this.scanner.source,
-            start: from,
-            end: to ?? this.scanner.position()
-        };
-    }
-    #defs(type) {
-        switch (type) {
-            case interface_1.NodeType.SystemModifier: return this.cxt.config.systemModifiers;
-            case interface_1.NodeType.InlineModifier: return this.cxt.config.inlineModifiers;
-            case interface_1.NodeType.BlockModifier: return this.cxt.config.blockModifiers;
-            default: return debug_1.debug.never(type);
-        }
-    }
-    #reparse(nodes, depth) {
-        if (depth > this.cxt.config.reparseDepthLimit)
-            return false;
-        let ok = true;
-        for (const node of nodes) {
-            switch (node.type) {
-                case interface_1.NodeType.Preformatted:
-                case interface_1.NodeType.Text:
-                case interface_1.NodeType.Escaped:
-                    continue;
-                case interface_1.NodeType.Paragraph:
-                    ok = this.#reparse(node.content, depth + 1) && ok;
-                    continue;
-                case interface_1.NodeType.BlockModifier:
-                case interface_1.NodeType.InlineModifier:
-                case interface_1.NodeType.SystemModifier:
-                    ok = this.#expand(node, depth + 1) && ok;
-                    continue;
-                default:
-                    debug_1.debug.never(node);
-            }
-        }
-        return ok;
-    }
-    #expandArgument(arg) {
-        if (arg.expansion !== undefined)
-            return arg.expansion;
-        let result = '';
-        const immediate = this.delayDepth == 0;
-        for (const e of arg.content) {
-            switch (e.type) {
-                case interface_1.NodeType.Text:
-                case interface_1.NodeType.Escaped:
-                    result += e.content;
-                    break;
-                case interface_1.NodeType.Interpolation:
-                    if (e.expansion === undefined) {
-                        const inner = this.#expandArgument(e.argument);
-                        if (inner === undefined
-                            || e.definition.expand === undefined
-                            || (!immediate && !e.definition.alwaysTryExpand))
-                            return undefined;
-                        e.expansion = e.definition.expand(inner, this.cxt, immediate);
-                        if (e.expansion === undefined)
-                            return undefined;
-                    }
-                    result += e.expansion;
-                    break;
-                default:
-                    debug_1.debug.never(e);
-            }
-        }
-        // debug.trace('expanded arg:', result);
-        arg.expansion = result;
-        return result;
-    }
-    #expandArguments(node) {
-        for (const arg of node.arguments) {
-            this.#expandArgument(arg);
-            // if (!arg.expansion) debug.trace('expand arg failed');
-        }
-    }
-    #expand(node, depth = 0) {
-        if (node.expansion !== undefined) {
-            debug_1.debug.trace('already expanded, skipping:', node.mod.name);
-            return true;
-        }
-        if (depth > 0) {
-            this.#expandArguments(node);
-        }
-        if (this.delayDepth > 0 && !node.mod.alwaysTryExpand) {
-            debug_1.debug.trace('delaying expansion of', node.mod.name);
-            return true;
-        }
-        const immediate = this.delayDepth == 0;
-        if (depth > 0) {
-            // simulate initial parse for generated content
-            if (node.mod.beforeParseContent)
-                this.emit.message(...node.mod.beforeParseContent(node, this.cxt, immediate));
-            if (node.content.length > 0) {
-                if (node.mod.delayContentExpansion)
-                    this.delayDepth++;
-                this.#reparse(node.content, depth);
-                if (node.mod.delayContentExpansion)
-                    this.delayDepth--;
-            }
-            if (node.mod.afterParseContent)
-                this.emit.message(...node.mod.afterParseContent(node, this.cxt, immediate));
-        }
-        if (node.mod.prepareExpand)
-            this.emit.message(...node.mod.prepareExpand(node, this.cxt, immediate));
-        if (node.mod.expand) {
-            node.expansion = node.mod.expand(node, this.cxt, immediate);
-            if (!node.expansion) {
-                // debug.trace('manually delaying expansion of', node.mod.name);
-                return true;
-            }
-            debug_1.debug.trace(`${this.delayDepth > 0 ? 'early ' : ''}expanding:`, node.mod.name);
-            if (node.expansion.length > 0)
-                debug_1.debug.trace(() => '-->\n' + debug_print_1.debugPrint.node(...node.expansion));
-        }
-        const expansion = node.expansion ?? node.content;
-        if (expansion.length == 0)
-            return true;
-        if (node.mod.beforeProcessExpansion)
-            this.emit.message(...node.mod.beforeProcessExpansion(node, this.cxt, immediate));
-        let ok = this.#reparse(expansion, depth);
-        if (node.mod.afterProcessExpansion)
-            this.emit.message(...node.mod.afterProcessExpansion(node, this.cxt, immediate));
-        if (!ok && depth == 0) {
-            const limit = this.cxt.config.reparseDepthLimit;
-            this.emit.message(new messages_1.ReachedRecursionLimitMessage(node.location, limit, node.mod.name));
-        }
-        return ok;
-    }
-    parse() {
-        this.DOCUMENT();
-        return new parser_config_1.Document(this.emit.root, this.cxt, this.emit.messages);
-    }
-    WHITESPACES() {
-        while (this.scanner.acceptWhitespaceChar() !== null) { }
-    }
-    WHITESPACES_OR_NEWLINES() {
-        while (this.scanner.acceptWhitespaceChar() !== null
-            || this.scanner.accept('\n')) { }
-    }
-    SHOULD_BE_A_NEWLINE() {
-        this.WHITESPACES();
-        if (!this.scanner.accept('\n'))
-            this.emit.message(new messages_1.ContentShouldBeOnNewlineMessage(this.#loc()));
-    }
-    // TODO: this is awkward and doesn't emit messages in the most appropriate way
-    WARN_IF_MORE_NEWLINES_THAN(n) {
-        let nlines = 0;
-        const start = this.scanner.position();
-        while (true) {
-            if (this.scanner.accept('\n')) {
-                nlines++;
-                continue;
-            }
-            if (this.scanner.acceptWhitespaceChar() == null)
-                break;
-        }
-        const end = this.scanner.position();
-        if (nlines > n)
-            this.emit.message(new messages_1.UnnecessaryNewlineMessage(this.#locFrom(start, end)));
-    }
-    DOCUMENT() {
-        this.WHITESPACES_OR_NEWLINES();
-        while (!this.scanner.isEOF()) {
-            this.BLOCK_ENTITY();
-            this.WHITESPACES_OR_NEWLINES();
-        }
-    }
-    BLOCK_ENTITY() {
-        (0, util_1.assert)(!this.scanner.isEOF());
-        if (this.scanner.peek(MODIFIER_BLOCK_OPEN)) {
-            this.MODIFIER(interface_1.NodeType.BlockModifier);
-            return;
-        }
-        if (this.scanner.peek(MODIFIER_SYSTEM_OPEN)) {
-            this.MODIFIER(interface_1.NodeType.SystemModifier);
-            return;
-        }
-        const short = this.cxt.config.blockShorthands.find((x) => this.scanner.accept(x.name));
-        if (short)
-            return this.SHORTHAND(interface_1.NodeType.BlockModifier, short);
-        // simple paragraph(s)
-        this.MAYBE_GROUPED_PARAGRAPH();
-    }
-    MODIFIER(type) {
-        const posStart = this.scanner.position();
-        (0, util_1.assert)(this.scanner.accept({
-            [interface_1.NodeType.BlockModifier]: MODIFIER_BLOCK_OPEN,
-            [interface_1.NodeType.SystemModifier]: MODIFIER_SYSTEM_OPEN,
-            [interface_1.NodeType.InlineModifier]: MODIFIER_INLINE_OPEN
-        }[type]));
-        const result = this.#defs(type).find((x) => this.scanner.accept(x.name));
-        const mod = result ?? UnknownModifier[type];
-        if (result === undefined) {
-            let name = '';
-            while (!this.scanner.isEOF()
-                && !this.scanner.acceptWhitespaceChar()
-                && !this.scanner.peek(MODIFIER_CLOSE_SIGN)
-                && !this.scanner.peek(MODIFIER_END_SIGN)) {
-                if (this.scanner.accept('\\'))
-                    if (this.scanner.isEOF())
-                        break;
-                name += this.scanner.acceptChar();
-            }
-            this.emit.message(new messages_1.UnknownModifierMessage(this.#locFrom(posStart), name));
-        }
-        const args = this.ARGUMENTS();
-        debug_1.debug.trace(`PARSE ${interface_1.NodeType[type]}:`, mod.name);
-        const endsign = this.scanner.accept(MODIFIER_END_SIGN);
-        const flagMarker = mod.slotType == interface_1.ModifierSlotType.None;
-        if (!this.scanner.accept(MODIFIER_CLOSE_SIGN))
-            this.emit.message(new messages_1.ExpectedMessage(this.#loc(), MODIFIER_CLOSE_SIGN));
-        const headEnd = this.scanner.position();
-        const node = {
-            type, mod: mod,
-            head: this.#locFrom(posStart, headEnd),
-            location: this.#locFrom(posStart, headEnd),
-            arguments: args,
-            content: [],
-            expansion: undefined
-        };
-        const isMarker = flagMarker || endsign;
-        return this.MODIFIER_BODY(type, node, MODIFIER_INLINE_END_TAG, isMarker);
-    }
-    // also handles "grouped" (delimited) pre-paragraphs
-    PRE_PARAGRAPH() {
-        (0, util_1.assert)(!this.scanner.isEOF());
-        const posStart = this.scanner.position();
-        const grouped = this.scanner.accept(GROUP_BEGIN);
-        if (grouped)
-            this.SHOULD_BE_A_NEWLINE();
-        const posContentStart = this.scanner.position();
-        let posContentEnd = this.scanner.position();
-        let string = '';
-        while (!this.scanner.isEOF()) {
-            if (this.scanner.accept('\n')) {
-                let white = "\n";
-                let char;
-                while ((char = this.scanner.acceptWhitespaceChar()) !== null)
-                    white += char;
-                if (grouped && this.scanner.accept(GROUP_END)) {
-                    this.SHOULD_BE_A_NEWLINE();
-                    this.WARN_IF_MORE_NEWLINES_THAN(1);
-                    break;
-                }
-                if (!grouped && this.scanner.accept('\n')) {
-                    this.WARN_IF_MORE_NEWLINES_THAN(0);
-                    break;
-                }
-                if (this.scanner.isEOF()) {
-                    if (grouped)
-                        this.emit.message(new messages_1.ExpectedMessage(this.#loc(), GROUP_END));
-                    break;
-                }
-                string += white;
-            }
-            else {
-                string += this.scanner.acceptChar();
-            }
-            posContentEnd = this.scanner.position();
-        }
-        const node = {
-            type: interface_1.NodeType.Preformatted,
-            location: this.#locFrom(posStart),
-            content: {
-                start: posContentStart,
-                end: posContentEnd,
-                text: string
-            }
-        };
-        this.emit.addBlockNode(node);
-    }
-    MAYBE_GROUPED_PARAGRAPH() {
-        (0, util_1.assert)(!this.scanner.isEOF());
-        if (this.scanner.accept(GROUP_BEGIN)) {
-            this.groupDepth++;
-            this.SHOULD_BE_A_NEWLINE();
-            this.WARN_IF_MORE_NEWLINES_THAN(1);
-            while (!this.scanner.isEOF()) {
-                if (this.scanner.accept(GROUP_END)) {
-                    this.groupDepth--;
-                    return;
-                }
-                this.BLOCK_ENTITY();
-                this.WARN_IF_MORE_NEWLINES_THAN(1);
-            }
-            // EOF
-            this.emit.message(new messages_1.ExpectedMessage(this.#loc(), GROUP_END));
-        }
-        else {
-            this.PARAGRAPH();
-        }
-    }
-    #trimNode(node) {
-        if (node.content.length == 0)
-            return;
-        let first = node.content[0];
-        let last = node.content.at(-1);
-        if (first.type == interface_1.NodeType.Text)
-            first.content = first.content.trimStart();
-        if (last.type == interface_1.NodeType.Text)
-            last.content = last.content.trimEnd();
-    }
-    PARAGRAPH() {
-        (0, util_1.assert)(!this.scanner.isEOF());
-        const node = {
-            type: interface_1.NodeType.Paragraph,
-            location: this.#loc(),
-            content: []
-        };
-        // debug.trace('PARSE para');
-        this.emit.startInline(node);
-        while (!this.scanner.isEOF() && this.INLINE_ENTITY()) { }
-        this.emit.endInline();
-        const last = node.content.at(-1);
-        node.location.actualEnd = last?.location.actualEnd ?? last?.location.end;
-        this.#trimNode(node);
-        // debug.trace('PARSE para end');
-    }
-    // returns false if breaking out of paragraph
-    SHORTHAND(type, d) {
-        const posStart = this.scanner.position() - d.name.length;
-        let args = [];
-        for (const part of d.parts) {
-            let [arg, ok] = this.ARGUMENT_CONTENT(part, ['\n\n']);
-            if (!ok) {
-                this.emit.message(new messages_1.ExpectedMessage(this.#loc(), part));
-                return false;
-            }
-            args.push(arg);
-        }
-        const headEnd = this.scanner.position();
-        const node = {
-            type, mod: d.mod,
-            head: this.#locFrom(posStart, headEnd),
-            location: this.#locFrom(posStart, headEnd),
-            arguments: args,
-            content: [],
-            expansion: undefined
-        };
-        const isMarker = node.mod.slotType == interface_1.ModifierSlotType.None;
-        return this.MODIFIER_BODY(type, node, d.postfix, isMarker);
-    }
-    MODIFIER_BODY(type, node, postfix, isMarker) {
-        this.#expandArguments(node);
-        const immediate = this.delayDepth == 0;
-        if (node.mod.beforeParseContent)
-            this.emit.message(...node.mod.beforeParseContent(node, this.cxt, immediate));
-        if (node.mod.delayContentExpansion)
-            this.delayDepth++;
-        let ok = true;
-        if (isMarker) {
-            if (type === interface_1.NodeType.InlineModifier)
-                this.emit.addInlineNode(node);
-            else
-                this.emit.addBlockNode(node);
-        }
-        else if (type == interface_1.NodeType.InlineModifier) {
-            node = node;
-            this.emit.startInline(node);
-            const pre = node.mod.slotType == interface_1.ModifierSlotType.Preformatted;
-            const entity = pre
-                ? this.PREFORMATTED_INLINE_ENTITY.bind(this)
-                : this.INLINE_ENTITY.bind(this);
-            while (true) {
-                if (postfix && this.scanner.accept(postfix))
-                    break;
-                if (this.scanner.isEOF() || !(ok = entity())) {
-                    // TODO: use error 3
-                    if (postfix)
-                        this.emit.message(new messages_1.ExpectedMessage(this.#loc(), postfix));
-                    break;
-                }
-            }
-            this.emit.endInline();
-            if (!pre && node.content.length > 0) {
-                this.#trimNode(node);
-            }
-        }
-        else {
-            this.emit.startBlock(node);
-            this.WARN_IF_MORE_NEWLINES_THAN(1);
-            if (!this.scanner.isEOF()) {
-                if (node.mod.slotType == interface_1.ModifierSlotType.Preformatted)
-                    this.PRE_PARAGRAPH();
-                else
-                    this.BLOCK_ENTITY();
-            }
-            this.emit.endBlock();
-        }
-        const last = node.content.at(-1);
-        node.location.actualEnd = last?.location.actualEnd ?? last?.location.end;
-        if (node.mod.delayContentExpansion)
-            this.delayDepth--;
-        if (node.mod.afterParseContent)
-            this.emit.message(...node.mod.afterParseContent(node, this.cxt, immediate));
-        this.#expand(node);
-        return ok;
-    }
-    // returns false if breaking out of paragraph
-    INLINE_ENTITY() {
-        (0, util_1.assert)(!this.scanner.isEOF());
-        if (this.scanner.peek(MODIFIER_INLINE_OPEN))
-            return this.MODIFIER(interface_1.NodeType.InlineModifier);
-        if (this.scanner.peek(MODIFIER_SYSTEM_OPEN))
-            return false;
-        const short = this.cxt.config.inlineShorthands.find((x) => this.scanner.accept(x.name));
-        if (short)
-            return this.SHORTHAND(interface_1.NodeType.InlineModifier, short);
-        if (this.scanner.accept('\\')) {
-            if (this.scanner.isEOF()) {
-                this.emit.addString('\\');
-                return true;
-            }
-            const start = this.scanner.position();
-            const node = {
-                type: interface_1.NodeType.Escaped,
-                content: this.scanner.acceptChar(),
-                location: this.#locFrom(start - 1)
-            };
-            this.emit.addInlineNode(node);
-            return true;
-        }
-        return this.PREFORMATTED_INLINE_ENTITY();
-    }
-    // returns false if breaking out of paragraph
-    PREFORMATTED_INLINE_ENTITY() {
-        (0, util_1.assert)(!this.scanner.isEOF());
-        if (this.scanner.accept('\n')) {
-            // these whitespaces in a blank line have no effect
-            this.WHITESPACES();
-            if (this.scanner.peek(MODIFIER_BLOCK_OPEN)
-                || this.scanner.peek(MODIFIER_SYSTEM_OPEN)
-                || this.cxt.config.blockShorthands.find((x) => this.scanner.peek(x.name))
-                || (this.scanner.peek(GROUP_END) && this.groupDepth > 0)
-                || this.scanner.isEOF())
-                return false;
-            if (this.scanner.accept('\n')) {
-                this.WARN_IF_MORE_NEWLINES_THAN(0);
-                return false;
-            }
-            this.emit.addString('\n');
-            return true;
-        }
-        // simple character
-        this.emit.addString(this.scanner.acceptChar());
-        return true;
-    }
-    // returns argument and isOk
-    ARGUMENT_CONTENT(end = undefined, close = [MODIFIER_END_SIGN, MODIFIER_CLOSE_SIGN]) {
-        let ok = true;
-        const content = [];
-        const posStart = this.scanner.position();
-        let posEnd = this.scanner.position();
-        const emitString = (s) => {
-            const last = content.at(-1);
-            if (last?.type == interface_1.NodeType.Text) {
-                last.content += s;
-                last.location.end += s.length;
-            }
-            else {
-                const end = this.scanner.position();
-                content.push({
-                    type: interface_1.NodeType.Text,
-                    location: this.#locFrom(end - s.length),
-                    content: s
-                });
-            }
-        };
-        while (true) {
-            if (end && this.scanner.accept(end))
-                break;
-            if (end === undefined && this.scanner.accept(':'))
-                break;
-            if (close.find((x) => this.scanner.peek(x))
-                || this.scanner.isEOF()) {
-                ok = false;
-                break;
-            }
-            if (this.scanner.accept('\\')) {
-                // handle escaping
-                posEnd = this.scanner.position();
-                if (this.scanner.isEOF()) {
-                    emitString('\\');
-                    ok = false;
-                    break;
-                }
-                content.push({
-                    type: interface_1.NodeType.Escaped,
-                    content: this.scanner.acceptChar(),
-                    location: this.#locFrom(posEnd - 1)
-                });
-                continue;
-            }
-            const beforeInterp = this.scanner.position();
-            const result = this.cxt.config.argumentInterpolators.find((x) => this.scanner.accept(x.name));
-            if (result !== undefined) {
-                const [inner, ok2] = this.ARGUMENT_CONTENT(result.postfix);
-                posEnd = this.scanner.position();
-                content.push({
-                    type: interface_1.NodeType.Interpolation,
-                    definition: result, argument: inner,
-                    location: this.#locFrom(beforeInterp)
-                });
-                if (!ok2) {
-                    this.emit.message(new messages_1.ExpectedMessage(this.#loc(), result.postfix));
-                    ok = false;
-                    break;
-                }
-            }
-            else {
-                emitString(this.scanner.acceptChar());
-                posEnd = this.scanner.position();
-            }
-        }
-        return [{
-                location: this.#locFrom(posStart, posEnd),
-                content
-            }, ok];
-    }
-    ARGUMENTS() {
-        // optionally accept semicolon before first argument
-        const firstSemicolon = this.scanner.accept(':');
-        // don't eat whites if there is a first semicolon
-        if (!firstSemicolon)
-            this.WHITESPACES_OR_NEWLINES();
-        const list = [];
-        let end = false;
-        while (!end) {
-            const [arg, ok] = this.ARGUMENT_CONTENT();
-            if (!ok) {
-                end = true;
-                // if we haven't parsed anything so far: if there is no first semicolon, there's no arguments; otherwise, there is a single empty argument
-                if (list.length == 0 && arg.content.length == 0 && !firstSemicolon)
-                    break;
-            }
-            list.push(arg);
-        }
-        return list;
-    }
-}
-function parse(scanner, cxt) {
-    return new Parser(scanner, cxt).parse();
-}
-//# sourceMappingURL=parser.js.map