@ui-doc/html-renderer 0.1.1

package/dist/index.mjs

@@ -0,0 +1,958 @@
+class HTMLRendererError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'HTMLRendererError';
+    }
+}
+
+class HTMLRendererSyntaxError extends SyntaxError {
+    constructor({ message, code, column, line, source, }) {
+        super(message);
+        this.name = 'HTMLRendererSyntaxError';
+        this.code = code;
+        this.line = line;
+        this.column = column;
+        this.source = source;
+        this.stack = `HTMLRendererSyntaxError: ${message}\n    in ${this.source}:${this.line}:${this.column}\n\n    ${code.replaceAll('\n', '\n    ')}`;
+    }
+}
+
+class ParserError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ParserError';
+    }
+}
+
+class TagNodeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TagNodeSyntaxError';
+    }
+}
+
+const IDENTIFIER_CHARS = {
+    identifier: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-.',
+    'tag-identifier': 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+};
+class HtmlCurlyBraceLexer {
+    constructor(reader) {
+        this.currentTokens = [];
+        this.tagConsuming = false;
+        this.tagIdentified = false;
+        this.reader = reader;
+    }
+    debug() {
+        return this.reader.debug();
+    }
+    peek(k = 1) {
+        this.consumeNextTokens(k);
+        return k === 1
+            ? this.currentTokens.slice(0, k)[0]
+            : this.currentTokens.slice(0, k);
+    }
+    consume(k = 1) {
+        this.consumeNextTokens(k);
+        return k === 1
+            ? this.currentTokens.splice(0, k)[0]
+            : this.currentTokens.splice(0, k);
+    }
+    consumeNextTokens(k = 1) {
+        while (this.currentTokens.length < k) {
+            this.currentTokens.push(this.consumeNextToken());
+        }
+    }
+    consumeNextToken() {
+        if (this.reader.isEof()) {
+            return undefined;
+        }
+        if (this.tagConsuming) {
+            return this.progressTag();
+        }
+        const char = this.reader.peak();
+        if (char === '{' && this.reader.peak(2) === '{{') {
+            return this.consumeTagOpen();
+        }
+        if (char === '<' && this.reader.peak(4) === '<!--') {
+            return this.consumeComment();
+        }
+        return this.consumeTemplate();
+    }
+    consumeTagOpen() {
+        this.reader.consume(2);
+        this.tagConsuming = true;
+        this.tagIdentified = false;
+        return {
+            type: 'tag-open',
+        };
+    }
+    consumeTagClose() {
+        this.reader.consume(2);
+        this.tagConsuming = false;
+        this.tagIdentified = false;
+        return {
+            type: 'tag-close',
+        };
+    }
+    consumeTagSeparator() {
+        this.reader.consume();
+        return {
+            type: 'tag-separator',
+        };
+    }
+    consumeComment() {
+        this.reader.consume(4);
+        let content = '';
+        while (!this.reader.isEof()) {
+            if (this.reader.peak(3) === '-->') {
+                this.reader.consume(3);
+                break;
+            }
+            content += this.reader.consume();
+        }
+        return {
+            content: content.trim(),
+            type: 'comment',
+        };
+    }
+    consumeTemplate() {
+        let content = '';
+        while (!this.reader.isEof()) {
+            const peek = this.reader.peak();
+            if (peek === '{' && this.reader.peak(2) === '{{') {
+                break;
+            }
+            if (peek === '<' && this.reader.peak(4) === '<!--') {
+                break;
+            }
+            content += this.reader.consume();
+        }
+        return {
+            content,
+            type: 'template',
+        };
+    }
+    progressTag() {
+        const char = this.reader.peak();
+        if (char === ' ' || char === '\n' || char === '\r' || char === '\t') {
+            this.reader.consume();
+            return this.progressTag();
+        }
+        if (char === '}' && this.reader.peak(2) === '}}') {
+            return this.consumeTagClose();
+        }
+        if (char === '/') {
+            return this.consumeTagEnd();
+        }
+        if (!this.tagIdentified) {
+            this.tagIdentified = true;
+            return this.consumeIdentifier('tag-identifier');
+        }
+        if (char === ':') {
+            return this.consumeTagSeparator();
+        }
+        if (char === '"' || char === "'") {
+            return this.consumeString();
+        }
+        if (char === '1' ||
+            char === '2' ||
+            char === '3' ||
+            char === '4' ||
+            char === '5' ||
+            char === '6' ||
+            char === '7' ||
+            char === '8' ||
+            char === '9' ||
+            char === '0') {
+            return this.consumeNumber();
+        }
+        if (char === 't' && this.reader.peak(4) === 'true') {
+            return this.consumeBoolean(true);
+        }
+        if (char === 'f' && this.reader.peak(5) === 'false') {
+            return this.consumeBoolean(false);
+        }
+        if (char === '=' || char === '!' || char === '<' || char === '>') {
+            return this.consumeOperator();
+        }
+        return this.consumeIdentifier();
+    }
+    consumeTagEnd() {
+        this.reader.consume();
+        return {
+            type: 'tag-end',
+        };
+    }
+    consumeString() {
+        const quote = this.reader.consume();
+        let value = '';
+        while (!this.reader.isEof()) {
+            const char = this.reader.consume();
+            if (char === quote) {
+                break;
+            }
+            value += char;
+        }
+        return {
+            type: 'string',
+            value,
+        };
+    }
+    consumeNumber() {
+        let value = '';
+        while (!this.reader.isEof()) {
+            const char = this.reader.peak();
+            if (char === '1' ||
+                char === '2' ||
+                char === '3' ||
+                char === '4' ||
+                char === '5' ||
+                char === '6' ||
+                char === '7' ||
+                char === '8' ||
+                char === '9' ||
+                char === '0' ||
+                char === '.') {
+                value += this.reader.consume();
+            }
+            else {
+                break;
+            }
+        }
+        return {
+            type: 'number',
+            value: parseFloat(value),
+        };
+    }
+    consumeBoolean(value) {
+        this.reader.consume(value ? 4 : 5);
+        return {
+            type: 'boolean',
+            value,
+        };
+    }
+    consumeOperator() {
+        let operator = '';
+        while (!this.reader.isEof()) {
+            const char = this.reader.peak();
+            if (char === '=' || char === '!' || char === '<' || char === '>') {
+                operator += this.reader.consume();
+            }
+            else {
+                break;
+            }
+        }
+        return {
+            operator,
+            type: 'operator',
+        };
+    }
+    consumeIdentifier(type = 'identifier') {
+        const chars = IDENTIFIER_CHARS[type];
+        let name = '';
+        while (!this.reader.isEof()) {
+            const char = this.reader.peak();
+            if (!chars.includes(char)) {
+                break;
+            }
+            name += this.reader.consume();
+        }
+        return {
+            name,
+            type,
+        };
+    }
+}
+
+class InlineReader {
+    constructor(input, source = 'inline') {
+        this.currentLine = 1;
+        this.currentPos = 1;
+        this.currentContent = '';
+        this.input = input;
+        this.source = source;
+    }
+    peak(k = 1) {
+        return this.input.slice(0, k);
+    }
+    consume(k = 1) {
+        const result = this.input.slice(0, k);
+        if (result.includes('\n')) {
+            const lines = result.split('\n');
+            this.currentLine += lines.length - 1;
+            this.currentContent = lines[lines.length - 1];
+            this.currentPos = this.currentContent.length + 1;
+        }
+        else {
+            this.currentPos += k;
+            this.currentContent += result;
+        }
+        this.input = this.input.slice(k);
+        return result;
+    }
+    isEof() {
+        return this.input.length === 0;
+    }
+    debug() {
+        const lines = this.input.split('\n', 1);
+        return {
+            content: this.currentContent + lines[0],
+            line: this.currentLine,
+            pos: this.currentPos,
+            source: this.source,
+        };
+    }
+}
+
+function instanceofReader(object) {
+    return (typeof object.peak === 'function' &&
+        typeof object.consume === 'function' &&
+        typeof object.isEof === 'function' &&
+        typeof object.debug === 'function');
+}
+class HtmlRenderer {
+    constructor(parser) {
+        this.layouts = {};
+        this.partials = {};
+        this.pages = {};
+        this.parser = parser;
+    }
+    addLayout(name, layout) {
+        this.layouts[name] = this.parse(layout);
+        return this;
+    }
+    addPartial(name, partial) {
+        this.partials[name] = this.parse(partial);
+        return this;
+    }
+    addPage(name, page) {
+        this.pages[name] = this.parse(page);
+        return this;
+    }
+    parse(input) {
+        const reader = !instanceofReader(input) ? new InlineReader(input.content, input.source) : input;
+        try {
+            return this.parser.parse(reader);
+        }
+        catch (error) {
+            if (error instanceof ParserError) {
+                const debug = reader.debug();
+                throw new HTMLRendererSyntaxError({
+                    code: debug.content,
+                    column: debug.pos,
+                    line: debug.line,
+                    message: error.message,
+                    source: debug.source,
+                });
+            }
+            throw error;
+        }
+    }
+    generate(context, layout) {
+        layout = layout !== null && layout !== void 0 ? layout : 'default';
+        const content = this.layouts[layout] || undefined;
+        if (!content) {
+            throw new HTMLRendererError(`Layout "${layout}" not found. Please register it using "addLayout" method.`);
+        }
+        return this.render(content, this.generateContext(context));
+    }
+    page(name, context) {
+        const content = this.pages[name] || this.pages.default || undefined;
+        if (!content) {
+            throw new HTMLRendererError(`Page "${name}" not found. Please register it using "addPage" method.`);
+        }
+        return this.render(content, context);
+    }
+    partial(name, context) {
+        const content = this.partials[name] || this.partials.default || undefined;
+        if (!content) {
+            throw new HTMLRendererError(`Partial "${name}" not found. Please register it using "addPartial" method.`);
+        }
+        return this.render(content, context !== null && context !== void 0 ? context : {});
+    }
+    render(rootNode, context) {
+        return rootNode.render(context, this);
+    }
+    generateContext(context) {
+        const renderContext = context;
+        renderContext.styles = context.assets
+            .filter((asset) => asset.type === 'style')
+            .map((asset) => `<link href="${asset.src}" rel="stylesheet"${this.makeAttributes(asset.attrs)}>`)
+            .join('\n');
+        renderContext.scripts = context.assets
+            .filter((asset) => asset.type === 'script')
+            .map((asset) => `<script src="${asset.src}"${this.makeAttributes(asset.attrs)}></script>`)
+            .join('\n');
+        return renderContext;
+    }
+    makeAttributes(attrs = {}) {
+        return Object.keys(attrs).reduce((result, key) => `${result} ${key}="${attrs[key]}"`, '');
+    }
+}
+
+const nodeOperators = ['==', '!=', '===', '!==', '<', '<=', '>', '>='];
+class Node {
+    constructor(type) {
+        this.childNodes = [];
+        this.type = type;
+    }
+    append(node) {
+        this.childNodes.push(node);
+    }
+    get children() {
+        return this.childNodes;
+    }
+    render(context, renderer) {
+        return this.renderChildNodes(context, renderer);
+    }
+    renderChildNodes(context, renderer) {
+        return this.childNodes.map(node => node.render(context, renderer)).join('');
+    }
+}
+
+class CommentNode extends Node {
+    constructor(content) {
+        super('comment');
+        this.content = content;
+    }
+    render() {
+        return `<!-- ${this.content} -->`;
+    }
+}
+
+function readNestedValue(name, target) {
+    const index = name.indexOf('.');
+    if (target === undefined || target === null) {
+        return undefined;
+    }
+    if (name === '') {
+        return target;
+    }
+    if (index <= 0) {
+        return target[name];
+    }
+    const currentName = name.substring(0, index);
+    const nextName = name.substring(index + 1);
+    if (!target[currentName]) {
+        return undefined;
+    }
+    return readNestedValue(nextName, target[currentName]);
+}
+function escapeHtml(unsafe) {
+    return unsafe
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#039;');
+}
+
+class TagNode extends Node {
+}
+
+class TagDebugNode extends TagNode {
+    constructor({ contextKey }) {
+        super('tag-debug');
+        this.contextKey = contextKey !== null && contextKey !== void 0 ? contextKey : 'this';
+    }
+    render(context) {
+        const debugContext = this.contextKey !== 'this' ? readNestedValue(this.contextKey, context) : context;
+        const debugContent = debugContext
+            ? JSON.stringify(debugContext, null, 2)
+            : `Current context for "${this.contextKey}" is empty`;
+        return `<pre>${debugContent}</pre>`;
+    }
+}
+const parseTagDebugNode = {
+    example: '{{ debug[:contextKey] }}',
+    hasContent: false,
+    identifier: 'debug',
+    parse() {
+        const options = {};
+        let gotSeparator = false;
+        return {
+            addToken(token) {
+                if (!gotSeparator) {
+                    if (token.type !== 'tag-separator') {
+                        throw new TagNodeError('Expected separator');
+                    }
+                    gotSeparator = true;
+                    return;
+                }
+                if (token.type === 'identifier') {
+                    options.contextKey = token.name;
+                    return;
+                }
+                throw new TagNodeError('Expected tag identifier');
+            },
+            create() {
+                return new TagDebugNode(options);
+            },
+        };
+    },
+};
+
+class TagForNode extends TagNode {
+    constructor({ contextKey }) {
+        super('tag-for');
+        this.contextKey = contextKey !== null && contextKey !== void 0 ? contextKey : 'this';
+    }
+    render(context, renderer) {
+        const contextNew = this.contextKey === 'this' ? context : readNestedValue(this.contextKey, context);
+        if (Array.isArray(contextNew)) {
+            return this.renderArray(contextNew, context, renderer);
+        }
+        if (typeof contextNew === 'object') {
+            return this.renderObject(contextNew, context, renderer);
+        }
+        return '';
+    }
+    renderArray(context, parentContext, renderer) {
+        return context
+            .map((item, index) => {
+            return this.renderChildNodes({
+                ...(typeof item === 'object' ? item : {}),
+                _contextKey: this.contextKey,
+                _loop: { index, value: item },
+                _parent: parentContext,
+            }, renderer);
+        })
+            .join('');
+    }
+    renderObject(context, parentContext, renderer) {
+        return Object.keys(context)
+            .map((key, index) => {
+            return this.renderChildNodes({
+                ...(typeof context[key] === 'object' ? context[key] : {}),
+                _contextKey: this.contextKey,
+                _loop: { index, key, value: context[key] },
+                _parent: parentContext,
+            }, renderer);
+        })
+            .join('');
+    }
+}
+const parseTagForNode = {
+    example: '{{ for[:contextKey] }}###{{ /for }}',
+    hasContent: true,
+    identifier: 'for',
+    parse() {
+        const options = {};
+        let gotSeparator = false;
+        return {
+            addToken(token) {
+                if (!gotSeparator) {
+                    if (token.type !== 'tag-separator') {
+                        throw new TagNodeError('Expected separator');
+                    }
+                    gotSeparator = true;
+                    return;
+                }
+                if (token.type === 'identifier') {
+                    options.contextKey = token.name;
+                    return;
+                }
+                throw new TagNodeError('Expected tag identifier"');
+            },
+            create() {
+                return new TagForNode(options);
+            },
+        };
+    },
+};
+
+class TagIfNode extends TagNode {
+    constructor(options) {
+        super('tag-if');
+        this.options = options;
+    }
+    render(context, renderer) {
+        let value = this.getValue(context, 'firstValue', 'firstContextKey');
+        if (this.options.operator) {
+            value = this.compare(value, this.getValue(context, 'secondValue', 'secondContextKey'), this.options.operator);
+        }
+        return value ? this.renderChildNodes(context, renderer) : '';
+    }
+    getValue(context, valueKey, contextKey) {
+        return this.options[contextKey] !== undefined
+            ? readNestedValue(this.options[contextKey], context)
+            : this.options[valueKey];
+    }
+    compare(value, compareValue, operator) {
+        switch (operator) {
+            case '==':
+                // eslint-disable-next-line eqeqeq
+                return value == compareValue;
+            case '!=':
+                // eslint-disable-next-line eqeqeq
+                return value != compareValue;
+            case '===':
+                return value === compareValue;
+            case '!==':
+                return value !== compareValue;
+            case '<':
+                return value < compareValue;
+            case '<=':
+                return value <= compareValue;
+            case '>':
+                return value > compareValue;
+            case '>=':
+                return value >= compareValue;
+            default:
+                return false;
+        }
+    }
+}
+const parseTagIfNode = {
+    example: '{{ if:(contextKey|contextKey === (true|"a string"|12.34)|contextKey === otherContextKey) }}###{{ /if }}',
+    hasContent: true,
+    identifier: 'if',
+    parse() {
+        const options = {};
+        const addOptionKeyOrValue = (token, keyName, valueName) => {
+            if (token.type === 'identifier') {
+                options[keyName] = token.name;
+                return;
+            }
+            if (token.type === 'string' || token.type === 'number' || token.type === 'boolean') {
+                options[valueName] = token.value;
+                return;
+            }
+            throw new TagNodeError('Expected identifier or value');
+        };
+        let gotSeparator = false;
+        return {
+            addToken(token) {
+                if (!gotSeparator) {
+                    if (token.type !== 'tag-separator') {
+                        throw new TagNodeError('Expected separator');
+                    }
+                    gotSeparator = true;
+                    return;
+                }
+                if (options.firstContextKey === undefined && options.firstValue === undefined) {
+                    addOptionKeyOrValue(token, 'firstContextKey', 'firstValue');
+                    return;
+                }
+                if (options.operator === undefined) {
+                    if (token.type !== 'operator') {
+                        throw new TagNodeError('Expected operator');
+                    }
+                    if (!nodeOperators.includes(token.operator)) {
+                        throw new TagNodeError(`Invalid operator ${token.operator}`);
+                    }
+                    options.operator = token.operator;
+                    return;
+                }
+                if (options.secondContextKey === undefined && options.secondValue === undefined) {
+                    addOptionKeyOrValue(token, 'secondContextKey', 'secondValue');
+                    return;
+                }
+                throw new TagNodeError('Unexpected token');
+            },
+            create() {
+                if (options.firstContextKey === undefined && options.firstValue === undefined) {
+                    throw new TagNodeError('Expected first context key or value');
+                }
+                if (options.operator === undefined && options.firstContextKey === undefined) {
+                    throw new TagNodeError('Expected context key when no operator is given');
+                }
+                if (options.operator !== undefined &&
+                    options.secondContextKey === undefined &&
+                    options.secondValue === undefined) {
+                    throw new TagNodeError('Expected second context key or value when operator is given');
+                }
+                return new TagIfNode(options);
+            },
+        };
+    },
+};
+
+class TagPageNode extends TagNode {
+    constructor({ name, contextKey }) {
+        super('tag-page');
+        this.name = name !== null && name !== void 0 ? name : 'default';
+        this.contextKey = contextKey !== null && contextKey !== void 0 ? contextKey : 'this';
+    }
+    render(context, renderer) {
+        let pageName = this.name;
+        const newContext = this.contextKey === 'this' ? context : readNestedValue(this.contextKey, context);
+        if (pageName.includes('.')) {
+            const foundName = readNestedValue(pageName, context);
+            if (typeof foundName === 'string' && foundName) {
+                pageName = foundName;
+            }
+        }
+        return renderer.page(pageName, newContext);
+    }
+}
+const parseTagPageNode = {
+    example: '{{ page[:page-name [contextKey]] }}',
+    hasContent: false,
+    identifier: 'page',
+    parse() {
+        const options = {};
+        let gotSeparator = false;
+        return {
+            addToken(token) {
+                if (!gotSeparator) {
+                    if (token.type !== 'tag-separator') {
+                        throw new TagNodeError('Expected separator');
+                    }
+                    gotSeparator = true;
+                    return;
+                }
+                if (token.type !== 'identifier') {
+                    throw new TagNodeError('Expected tag identifier');
+                }
+                if (options.name && options.contextKey) {
+                    throw new TagNodeError('Expected only one name and context key');
+                }
+                if (options.name) {
+                    options.contextKey = token.name;
+                }
+                else {
+                    options.name = token.name;
+                }
+            },
+            create() {
+                return new TagPageNode(options);
+            },
+        };
+    },
+};
+
+class TagPartialNode extends TagNode {
+    constructor({ name, contextKey }) {
+        super('tag-partial');
+        this.name = name;
+        this.contextKey = contextKey !== null && contextKey !== void 0 ? contextKey : 'this';
+    }
+    render(context, renderer) {
+        const newContext = this.contextKey === 'this' ? context : readNestedValue(this.contextKey, context);
+        return renderer.partial(this.name, newContext);
+    }
+}
+const parseTagPartialNode = {
+    example: '{{ partial:partial-name [contextKey] }}',
+    hasContent: false,
+    identifier: 'partial',
+    parse() {
+        const options = {};
+        let gotSeparator = false;
+        return {
+            addToken(token) {
+                if (!gotSeparator) {
+                    if (token.type !== 'tag-separator') {
+                        throw new TagNodeError('Expected separator');
+                    }
+                    gotSeparator = true;
+                    return;
+                }
+                if (token.type !== 'identifier') {
+                    throw new TagNodeError('Expected tag identifier');
+                }
+                if (options.name && options.contextKey) {
+                    throw new TagNodeError('Expected only one name and context key');
+                }
+                if (options.name) {
+                    options.contextKey = token.name;
+                }
+                else {
+                    options.name = token.name;
+                }
+            },
+            create() {
+                if (!options.name) {
+                    throw new TagNodeError('Expected partial name');
+                }
+                return new TagPartialNode(options);
+            },
+        };
+    },
+};
+
+class TagVarNode extends TagNode {
+    constructor({ contextKey, escape }) {
+        super('tag-var');
+        this.contextKey = contextKey;
+        this.escape = !!escape;
+    }
+    render(context) {
+        let value = readNestedValue(this.contextKey, context) || '';
+        if (typeof value !== 'string') {
+            value = String(value);
+        }
+        return this.escape ? escapeHtml(value) : value;
+    }
+}
+const parseTagVarNode = {
+    example: '{{ var:contextKey [escape] }}',
+    hasContent: false,
+    identifier: 'var',
+    parse() {
+        const options = {};
+        let gotSeparator = false;
+        return {
+            addToken(token) {
+                if (!gotSeparator) {
+                    if (token.type !== 'tag-separator') {
+                        throw new TagNodeError('Expected separator');
+                    }
+                    gotSeparator = true;
+                    return;
+                }
+                if (token.type !== 'identifier') {
+                    throw new TagNodeError('Expected tag identifier');
+                }
+                if (options.contextKey !== undefined && options.escape !== undefined) {
+                    throw new TagNodeError('Expected only context key followed by optional escape');
+                }
+                if (options.contextKey === undefined) {
+                    options.contextKey = token.name;
+                    return;
+                }
+                if (token.name !== 'escape') {
+                    throw new TagNodeError('Expected escape');
+                }
+                options.escape = true;
+            },
+            create() {
+                if (!options.contextKey) {
+                    throw new TagNodeError('Expected context key');
+                }
+                return new TagVarNode(options);
+            },
+        };
+    },
+};
+
+const tagNodes = [
+    parseTagDebugNode,
+    parseTagForNode,
+    parseTagIfNode,
+    parseTagPageNode,
+    parseTagPartialNode,
+    parseTagVarNode,
+];
+
+class TemplateNode extends Node {
+    constructor(content) {
+        super('template');
+        this.content = content;
+    }
+    render() {
+        return this.content;
+    }
+}
+
+class NodeParser {
+    constructor() {
+        this.tags = {};
+    }
+    static init() {
+        const parser = new NodeParser();
+        tagNodes.forEach(tag => parser.registerTagParser(tag));
+        // TODO may make async
+        // (await import('./nodes/tags')).default.forEach(tag => parser.registerTag(tag))
+        return parser;
+    }
+    registerTagParser(tag) {
+        this.tags[tag.identifier] = tag;
+        return this;
+    }
+    parse(reader) {
+        const lexer = new HtmlCurlyBraceLexer(reader);
+        const tree = new Node('root');
+        return this.parseChildren(lexer, tree);
+    }
+    parseChildren(lexer, parent) {
+        var _a;
+        let token = lexer.consume();
+        while (token) {
+            switch (token.type) {
+                case 'template':
+                    parent.append(new TemplateNode(token.content));
+                    break;
+                case 'comment':
+                    parent.append(new CommentNode(token.content));
+                    break;
+                case 'tag-open':
+                    if (((_a = lexer.peek()) === null || _a === void 0 ? void 0 : _a.type) === 'tag-end') {
+                        return parent;
+                    }
+                    parent.append(this.parseTag(lexer));
+                    break;
+                default:
+                    throw new ParserError(`Unexpected token type "${token.type}"`);
+            }
+            token = lexer.consume();
+        }
+        return parent;
+    }
+    parseTag(lexer) {
+        var _a, _b, _c;
+        const tagIdentifier = lexer.consume();
+        if (!tagIdentifier || tagIdentifier.type !== 'tag-identifier') {
+            throw new ParserError('Expected tag identifier');
+        }
+        const tagDefinition = this.tags[tagIdentifier.name];
+        if (!tagDefinition) {
+            throw new ParserError(`Unknown tag "${tagIdentifier.name}"`);
+        }
+        const { addToken, create } = tagDefinition.parse();
+        let nextToken = lexer.consume();
+        let node;
+        try {
+            while (nextToken && nextToken.type !== 'tag-close') {
+                addToken(nextToken);
+                nextToken = lexer.consume();
+            }
+            node = create();
+        }
+        catch (error) {
+            if (error instanceof TagNodeError) {
+                throw new ParserError(`Error parsing tag ${tagIdentifier.name} - ${error.message}\nShould be something like: ${tagDefinition.example}`);
+            }
+            throw error;
+        }
+        if (!tagDefinition.hasContent) {
+            return node;
+        }
+        this.parseChildren(lexer, node);
+        const closeTokens = lexer.consume(3);
+        if (!closeTokens ||
+            ((_a = closeTokens[0]) === null || _a === void 0 ? void 0 : _a.type) !== 'tag-end' ||
+            ((_b = closeTokens[1]) === null || _b === void 0 ? void 0 : _b.type) !== 'tag-identifier' ||
+            closeTokens[1].name !== tagIdentifier.name ||
+            ((_c = closeTokens[2]) === null || _c === void 0 ? void 0 : _c.type) !== 'tag-close') {
+            throw new ParserError('Expected closing tag');
+        }
+        return node;
+    }
+}
+
+class TemplateLoader {
+    static async load({ renderer, fileSystem, templateBasePath = '@ui-doc/html-renderer/templates', }) {
+        const templatePath = await fileSystem.assetLoader().packagePath(templateBasePath);
+        const layoutFinder = fileSystem.createFileFinder([`${templatePath}/layouts/*.html`]);
+        const pageFinder = fileSystem.createFileFinder([`${templatePath}/pages/*.html`]);
+        const partialFinder = fileSystem.createFileFinder([`${templatePath}/partials/*.html`]);
+        const name = (file) => fileSystem.fileBasename(file);
+        const content = async (file) => (await fileSystem.fileRead(file)).trim();
+        await Promise.all([
+            layoutFinder.search(async (file) => {
+                renderer.addLayout(name(file), { content: await content(file), source: file });
+            }),
+            pageFinder.search(async (file) => {
+                renderer.addPage(name(file), { content: await content(file), source: file });
+            }),
+            partialFinder.search(async (file) => {
+                renderer.addPartial(name(file), { content: await content(file), source: file });
+            }),
+        ]);
+    }
+}
+
+export { CommentNode, HTMLRendererError, HTMLRendererSyntaxError, HtmlCurlyBraceLexer, HtmlRenderer, InlineReader, Node, NodeParser, ParserError, TagDebugNode, TagForNode, TagIfNode, TagNode, TagNodeError, TagPageNode, TagPartialNode, TagVarNode, TemplateLoader, TemplateNode, escapeHtml, nodeOperators, readNestedValue };
+//# sourceMappingURL=index.mjs.map