moost 0.0.1 → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,2093 @@
+'use strict';
+
+var eventCore = require('@wooksjs/event-core');
+require('url');
+require('stream');
+require('http');
+var mate = require('@prostojs/mate');
+var infact = require('@prostojs/infact');
+var valido$1 = require('@prostojs/valido');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+const dim = '';
+const reset = '';
+class ProstoTree {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        const label = (options === null || options === void 0 ? void 0 : options.label) || 'label';
+        const children = (options === null || options === void 0 ? void 0 : options.children) || 'children';
+        const branchWidth = typeof (options === null || options === void 0 ? void 0 : options.branchWidth) === 'number' ? options === null || options === void 0 ? void 0 : options.branchWidth : 2;
+        const hLine = (((_a = options === null || options === void 0 ? void 0 : options.branches) === null || _a === void 0 ? void 0 : _a.hLine) || '─').repeat(branchWidth - 1);
+        const branches = {
+            end: ((_b = options === null || options === void 0 ? void 0 : options.branches) === null || _b === void 0 ? void 0 : _b.end) || dim + '└',
+            middle: ((_c = options === null || options === void 0 ? void 0 : options.branches) === null || _c === void 0 ? void 0 : _c.middle) || dim + '├',
+            vLine: ((_d = options === null || options === void 0 ? void 0 : options.branches) === null || _d === void 0 ? void 0 : _d.vLine) || dim + '│',
+            hLine,
+        };
+        this.options = {
+            label: label,
+            children: children,
+            renderLabel: (options === null || options === void 0 ? void 0 : options.renderLabel) || (n => typeof n === 'string' ? n : n[label]),
+            branches,
+            branchWidth,
+        };
+    }
+    _render(root, opts) {
+        const { children, renderLabel } = this.options;
+        let s = `${renderLabel(root, '')}\n`;
+        const { end, middle, vLine, hLine } = this.options.branches;
+        const endBranch = end + hLine + reset + ' ';
+        const middleBranch = middle + hLine + reset + ' ';
+        const { branchWidth } = this.options;
+        if (root) {
+            treeNode(root);
+        }
+        function treeNode(node, behind = '', level = 1) {
+            const items = (node && node[children]);
+            const count = items && items.length || 0;
+            if (items) {
+                if ((opts === null || opts === void 0 ? void 0 : opts.level) && opts.level < level) {
+                    s += behind + endBranch + renderCollapsedChildren(items.length) + '\n';
+                }
+                else {
+                    let itemsToRender = items;
+                    const collapsedCount = Math.max(0, count - ((opts === null || opts === void 0 ? void 0 : opts.childrenLimit) || count));
+                    if ((opts === null || opts === void 0 ? void 0 : opts.childrenLimit) && count > opts.childrenLimit) {
+                        itemsToRender = opts.showLast ? items.slice(count - opts.childrenLimit) : items.slice(0, opts.childrenLimit);
+                    }
+                    if (collapsedCount && (opts === null || opts === void 0 ? void 0 : opts.showLast))
+                        s += behind + middleBranch + renderCollapsedChildren(collapsedCount) + '\n';
+                    itemsToRender.forEach((childNode, i) => {
+                        const last = i + 1 === count;
+                        const branch = last ? endBranch : middleBranch;
+                        const nextBehind = behind + (last ? ' ' : vLine) + ' '.repeat(branchWidth);
+                        s += behind + branch + renderLabel(childNode, nextBehind) + '\n';
+                        if (typeof childNode === 'object') {
+                            treeNode(childNode, nextBehind, level + 1);
+                        }
+                    });
+                    if (collapsedCount && !(opts === null || opts === void 0 ? void 0 : opts.showLast))
+                        s += behind + endBranch + renderCollapsedChildren(collapsedCount) + '\n';
+                }
+            }
+        }
+        return s;
+    }
+    render(root, opts) {
+        return this._render(root, opts);
+    }
+    print(root, opts) {
+        const s = this.render(root, opts);
+        console.log(s);
+        return s;
+    }
+}
+function renderCollapsedChildren(count) {
+    return dim + '+ ' + '' + count.toString() + ` item${count === 1 ? '' : 's'}` + reset;
+}
+
+function renderCodeFragment(lines, options) {
+    const row = (options.row || 1) - 1;
+    const rowEnd = options.rowEnd ? options.rowEnd - 1 : -1;
+    const limit = Math.min(options.limit || 6, lines.length);
+    const offset = Math.min(options.offset || 3, lines.length);
+    const error = options.error;
+    const errorEnd = options.errorEnd;
+    let output = '';
+    const delta = rowEnd - row;
+    const maxIndex = lines.length;
+    if (delta > limit) {
+        let longestLine = 0;
+        const newLimit = Math.floor(limit / 2);
+        for (let i = 0; i < newLimit + offset; i++) {
+            const index = row + i - offset;
+            const line = lines[index] || '';
+            longestLine = Math.max(line.length, longestLine);
+            output += renderLine(line, index < maxIndex ? index + 1 : '', index === row ? error : undefined, index === row || index === rowEnd ? 'bold' : '');
+        }
+        let output2 = '';
+        for (let i = newLimit + offset; i > 0; i--) {
+            const index = rowEnd - i + offset;
+            const line = lines[index] || '';
+            longestLine = Math.max(line.length, longestLine);
+            output2 += renderLine(line, index < maxIndex ? index + 1 : '', index === rowEnd ? errorEnd : undefined, index === row || index === rowEnd ? 'bold' : '');
+        }
+        output += renderLine('—'.repeat(longestLine), '———', undefined, 'dim') + output2;
+    }
+    else {
+        for (let i = 0; i < limit + offset; i++) {
+            const index = row + i - offset;
+            if (index <= lines.length + 1) {
+                const errorCol = index === row ? error : index === rowEnd ? errorEnd : undefined;
+                output += renderLine(lines[index], index < maxIndex ? index + 1 : '', errorCol, index === row || index === rowEnd ? 'bold' : '');
+            }
+        }
+    }
+    return output;
+}
+function lineStyles(s) {
+    return '' + (s || '')
+        .replace(/([a-z_]+)/ig, '' + '$1' + '\x1b[39;33m')
+        .replace(/([\=\.\/'"`\:\+]+)/ig, '' + '$1' + '');
+}
+function lineStylesError(s) {
+    return '' + (s || '') + '';
+}
+function renderLine(line, index, error, style = '') {
+    const st = (style === 'bold' ? '' : '') + (style === 'dim' ? '' : '');
+    if (typeof error === 'number') {
+        const errorLength = (/[\.-\s\(\)\*\/\+\{\}\[\]\?\'\"\`\<\>]/.exec(line.slice(error + 1)) || { index: line.length - error }).index + 1;
+        return renderLineNumber(index, true) +
+            st +
+            lineStyles(line.slice(0, error)) +
+            lineStylesError(line.slice(error, error + errorLength)) +
+            lineStyles(line.slice(error + errorLength)) +
+            renderLineNumber('', true) + ' '.repeat(error) + '' + '' + '~'.repeat(Math.max(1, errorLength));
+    }
+    return renderLineNumber(index, undefined, style === 'bold') + st + lineStyles(line);
+}
+function renderLineNumber(i, isError = false, bold = false) {
+    let s = '      ';
+    const sep = i === '———';
+    if (i && i > 0 || typeof i === 'string') {
+        s = '      ' + String(i);
+    }
+    s = s.slice(s.length - 5);
+    return '\n' + '' + (sep ? '' : '') +
+        (isError ? '' + '' : (bold ? '' : '')) +
+        s + (sep ? i : ' | ') + '';
+}
+
+function escapeRegex(s) {
+    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+
+class ProstoParserNodeBase {
+    addRecognizes(...args) {
+        for (const node of args) {
+            if (!this.options.recognizes)
+                this.options.recognizes = [];
+            if (!this.options.recognizes.includes(node)) {
+                this.options.recognizes.push(node);
+            }
+        }
+        return this;
+    }
+    addAbsorbs(node, rule = 'append') {
+        this.options.absorbs = this.options.absorbs || {};
+        if (Array.isArray(node)) {
+            node.forEach(n => {
+                this.options.absorbs[n.id] = rule;
+                this.addRecognizes(n);
+            });
+        }
+        else {
+            this.options.absorbs[node.id] = rule;
+            this.addRecognizes(node);
+        }
+        return this;
+    }
+    addPopsAfterNode(...args) {
+        for (const node of args) {
+            if (!this.options.popsAfterNode)
+                this.options.popsAfterNode = [];
+            if (!this.options.popsAfterNode.includes(node)) {
+                this.options.popsAfterNode.push(node);
+            }
+        }
+        this.addRecognizes(...args);
+        return this;
+    }
+    addHoistChildren(...args) {
+        if (!this.options.hoistChildren)
+            this.options.hoistChildren = [];
+        this.options.hoistChildren.push(...args);
+        return this;
+    }
+    set icon(value) {
+        this.options.icon = value;
+    }
+    set label(value) {
+        this.options.label = value;
+    }
+    get startsWith() {
+        return this.options.startsWith;
+    }
+    set startsWith(value) {
+        this.options.startsWith = value;
+    }
+    get endsWith() {
+        return this.options.endsWith;
+    }
+    set endsWith(value) {
+        this.options.endsWith = value;
+    }
+    getPopsAtEOFSource() {
+        return this.options.popsAtEOFSource;
+    }
+    popsAtEOFSource(value) {
+        this.options.popsAtEOFSource = value;
+        return this;
+    }
+    get absorbs() {
+        return this.options.absorbs;
+    }
+    get badToken() {
+        return this.options.badToken;
+    }
+    set badToken(value) {
+        this.options.badToken = value;
+    }
+    get skipToken() {
+        return this.options.skipToken;
+    }
+    set skipToken(value) {
+        this.options.skipToken = value;
+    }
+    get recognizes() {
+        return this.options.recognizes || [];
+    }
+    set recognizes(value) {
+        this.options.recognizes = value;
+    }
+    get hoistChildren() {
+        return this.options.hoistChildren || [];
+    }
+    set hoistChildren(value) {
+        this.options.hoistChildren = value;
+    }
+    getMapContent() {
+        return this.options.mapContent;
+    }
+    mapContent(key, value = 'copy') {
+        this.options.mapContent = this.options.mapContent || {};
+        this.options.mapContent[key] = value;
+        return this;
+    }
+    onMatch(value) {
+        this.options.onMatch = value;
+        return this;
+    }
+    onAppendContent(value) {
+        this.options.onAppendContent = value;
+        return this;
+    }
+    onAfterChildParse(value) {
+        this.options.onAfterChildParse = value;
+        return this;
+    }
+    onBeforeChildParse(value) {
+        this.options.onBeforeChildParse = value;
+        return this;
+    }
+    onMatchStartToken(value) {
+        if (this.options.startsWith) {
+            this.options.startsWith.onMatchToken = value;
+        }
+        return this;
+    }
+    onMatchEndToken(value) {
+        if (this.options.endsWith) {
+            this.options.endsWith.onMatchToken = value;
+        }
+        return this;
+    }
+    initCustomData(value) {
+        this.options.initCustomData = value;
+        return this;
+    }
+    onPop(value) {
+        this.options.onPop = value;
+        return this;
+    }
+    get popsAfterNode() {
+        return this.options.popsAfterNode || [];
+    }
+    set popsAfterNode(nodes) {
+        this.options.popsAfterNode = nodes;
+    }
+    clearStartsWith() {
+        delete this.options.startsWith;
+        return this;
+    }
+    clearEndsWith() {
+        delete this.options.endsWith;
+        return this;
+    }
+    clearPopsAtEOFSource() {
+        delete this.options.popsAtEOFSource;
+        return this;
+    }
+    clearBadToken() {
+        delete this.options.badToken;
+        return this;
+    }
+    clearSkipToken() {
+        delete this.options.skipToken;
+        return this;
+    }
+    clearAbsorbs(node) {
+        if (this.options.absorbs) {
+            if (node && Array.isArray(node)) {
+                for (const n of node) {
+                    delete this.options.absorbs[n.id];
+                }
+            }
+            else if (node) {
+                delete this.options.absorbs[node.id];
+            }
+            else {
+                this.options.absorbs = {};
+            }
+        }
+        return this;
+    }
+    clearRecognizes(...args) {
+        var _a;
+        if (args.length) {
+            this.options.recognizes = (_a = this.options.recognizes) === null || _a === void 0 ? void 0 : _a.filter(n => !args.includes(n));
+        }
+        else {
+            this.options.recognizes = [];
+        }
+        return this;
+    }
+    clearHoistChildren() {
+        delete this.options.hoistChildren;
+        return this;
+    }
+    clearMapContent() {
+        delete this.options.mapContent;
+        return this;
+    }
+    removeOnPop() {
+        delete this.options.onPop;
+        return this;
+    }
+    removeOnMatch() {
+        delete this.options.onMatch;
+        return this;
+    }
+    removeOnAppendContent() {
+        delete this.options.onAppendContent;
+        return this;
+    }
+    removeOnBeforeChildParse() {
+        delete this.options.onBeforeChildParse;
+        return this;
+    }
+    removeOnAfterChildParse() {
+        delete this.options.onAfterChildParse;
+        return this;
+    }
+    fireNodeMatched(matched, cbData) {
+        return this.options.startsWith ? this.fireMatched(this.options.startsWith, matched, cbData) : { confirmed: true };
+    }
+    fireNodeEndMatched(matched, cbData) {
+        return this.options.endsWith ? this.fireMatched(this.options.endsWith, matched, cbData) : { confirmed: true };
+    }
+    fireMatched(descr, matched, cbData) {
+        const { omit, eject, onMatchToken } = descr;
+        let cbResult = true;
+        if (onMatchToken) {
+            cbResult = onMatchToken({
+                ...cbData,
+                matched,
+            });
+        }
+        const cbOmit = typeof cbResult === 'object' ? cbResult.omit : undefined;
+        const cbEject = typeof cbResult === 'object' ? cbResult.eject : undefined;
+        return {
+            omit: cbOmit !== undefined ? cbOmit : omit,
+            eject: cbEject !== undefined ? cbEject : eject,
+            confirmed: cbResult !== false,
+        };
+    }
+    getStartTokenRg() {
+        return this.getRgOutOfTokenDescriptor(this.options.startsWith);
+    }
+    getEndTokenRg() {
+        return this.getRgOutOfTokenDescriptor(this.options.endsWith);
+    }
+    getConstraintTokens() {
+        return {
+            skip: this.getRgOutOfTokenDescriptor(this.options.skipToken ? { token: this.options.skipToken } : undefined) || undefined,
+            bad: this.getRgOutOfTokenDescriptor(this.options.badToken ? { token: this.options.badToken } : undefined) || undefined,
+        };
+    }
+    getRgOutOfTokenDescriptor(descr) {
+        if (descr) {
+            const prefix = descr.ignoreBackSlashed ? /(?<=(?:^|[^\\])(?:\\\\)*)/.source : '';
+            let token;
+            if (typeof descr.token === 'function') {
+                token = descr.token(this);
+            }
+            else {
+                token = descr.token;
+            }
+            if (token instanceof RegExp) {
+                return new RegExp(prefix + token.source, token.flags);
+            }
+            else {
+                return new RegExp(`${prefix}(?:${[token].flat().map(t => escapeRegex(t)).join('|')})`);
+            }
+        }
+    }
+}
+
+class ProstoHoistManager {
+    constructor() {
+        this.data = {};
+    }
+    addHoistOptions(ctx) {
+        if (ctx.hoistChildren) {
+            ctx.hoistChildren.forEach(options => {
+                const nodeId = typeof options.node === 'object' ? options.node.id : options.node;
+                const hoist = this.data[nodeId] = (this.data[nodeId] || {});
+                if (hoist) {
+                    hoist[ctx.index] = {
+                        options,
+                        context: ctx,
+                    };
+                }
+            });
+        }
+    }
+    removeHoistOptions(ctx) {
+        if (ctx.hoistChildren) {
+            ctx.hoistChildren.forEach(options => {
+                const nodeId = typeof options.node === 'object' ? options.node.id : options.node;
+                const hoist = this.data[nodeId];
+                if (hoist) {
+                    delete hoist[ctx.index];
+                }
+            });
+        }
+    }
+    processHoistOptions(ctx) {
+        const id = ctx.node.id;
+        const hoist = this.data[id];
+        if (hoist) {
+            Object.keys(hoist).map(i => hoist[i]).forEach(({ options, context }) => {
+                const customData = context.getCustomData();
+                if (options.deep === true || Number(options.deep) >= (ctx.level - context.level)) {
+                    if (options.asArray) {
+                        const hoisted = customData[options.as] = (customData[options.as] || []);
+                        if (!Array.isArray(hoisted)) {
+                            if (!options.onConflict || options.onConflict === 'error') {
+                                throw new Error(`Can not hoist "${ctx.node.name}" to "${context.node.name}" as "${options.as}". "${options.as}" already exists and it is not an Array Type.`);
+                            }
+                            else if (options.onConflict === 'overwrite') {
+                                customData[options.as] = [doTheMapRule(options, ctx)];
+                            }
+                            else if (options.onConflict !== 'ignore') {
+                                throw new Error(`Unsupported hoisting option onConflict "${options.onConflict}"`);
+                            }
+                        }
+                        else {
+                            hoisted.push(doTheMapRule(options, ctx));
+                        }
+                    }
+                    else {
+                        if (customData[options.as]) {
+                            if (!options.onConflict || options.onConflict === 'error') {
+                                throw new Error(`Can not hoist multiple "${ctx.node.name}" to "${context.node.name}" as "${options.as}". "${options.as}" already exists.`);
+                            }
+                            else if (options.onConflict === 'overwrite') {
+                                customData[options.as] = doTheMapRule(options, ctx);
+                            }
+                            else if (options.onConflict !== 'ignore') {
+                                throw new Error(`Unsupported hoisting option onConflict "${options.onConflict}"`);
+                            }
+                        }
+                        else {
+                            customData[options.as] = doTheMapRule(options, ctx);
+                        }
+                    }
+                    if (options.removeChildFromContent) {
+                        context.content = context.content.filter(c => c !== ctx);
+                    }
+                }
+            });
+        }
+        function doTheMapRule(options, ctx) {
+            var _a;
+            if (typeof options.mapRule === 'function') {
+                return options.mapRule(ctx);
+            }
+            if (options.mapRule === 'content.join') {
+                return ctx.content.join('');
+            }
+            if ((_a = options.mapRule) === null || _a === void 0 ? void 0 : _a.startsWith('customData')) {
+                const key = options.mapRule.slice(11);
+                if (key) {
+                    return ctx.getCustomData()[key];
+                }
+                else {
+                    return ctx.getCustomData();
+                }
+            }
+            return ctx;
+        }
+    }
+}
+
+const banner$1 = '' + '[parser]' + '';
+class ProstoParserContext {
+    constructor(root) {
+        this.root = root;
+        this.nodes = {};
+        this.pos = 0;
+        this.index = 0;
+        this.behind = '';
+        this.here = '';
+        this.src = '';
+        this.stack = [];
+        this.l = 0;
+        this.hoistManager = new ProstoHoistManager();
+        this.context = root;
+    }
+    parse(src) {
+        this.src = src,
+            this.here = src,
+            this.l = src.length;
+        const cache = {};
+        while (this.pos < this.l) {
+            const searchTokens = this.context.getSearchTokens();
+            let closestIndex = Number.MAX_SAFE_INTEGER;
+            let closestToken;
+            let matched;
+            for (const t of searchTokens) {
+                const key = t.g.source;
+                t.g.lastIndex = this.pos;
+                let cached = cache[key];
+                if (cached === null)
+                    continue;
+                if (cached && cached.index < this.pos) {
+                    cached = null;
+                    delete cache[key];
+                }
+                if (!cached) {
+                    cached = t.g.exec(this.src);
+                    if (cached || (this.pos === 0 && !cached)) {
+                        cache[key] = cached;
+                    }
+                }
+                if (cached && cached.index < closestIndex) {
+                    closestIndex = cached.index;
+                    matched = cached;
+                    closestToken = t;
+                    if (closestIndex === this.pos)
+                        break;
+                }
+            }
+            if (closestToken && matched) {
+                const toAppend = this.src.slice(this.pos, closestIndex);
+                if (toAppend) {
+                    this.context.appendContent(toAppend);
+                    this.jump(toAppend.length);
+                }
+                const matchedToken = matched[0];
+                if (closestToken.node) {
+                    const { omit, eject, confirmed } = closestToken.node.fireNodeMatched(matched, this.getCallbackData(matched));
+                    if (!confirmed)
+                        continue;
+                    let toAppend = '';
+                    if (eject) {
+                        this.context.appendContent(matchedToken);
+                    }
+                    else if (!omit) {
+                        toAppend = matchedToken;
+                    }
+                    this.jump(matchedToken.length);
+                    this.pushNewContext(closestToken.node, toAppend ? [toAppend] : []);
+                    this.context.fireOnMatch(matched);
+                    continue;
+                }
+                else {
+                    const { omit, eject, confirmed } = this.context.fireNodeEndMatched(matched, this.getCallbackData(matched));
+                    if (!confirmed)
+                        continue;
+                    if (!eject && !omit) {
+                        this.context.appendContent(matchedToken);
+                    }
+                    if (!eject) {
+                        this.jump(matchedToken.length);
+                    }
+                    this.context.mapNamedGroups(matched);
+                    this.pop();
+                    continue;
+                }
+            }
+            else {
+                this.context.appendContent(this.here);
+                this.jump(this.here.length);
+            }
+        }
+        if (this.context !== this.root) {
+            while (this.context.getPopsAtEOFSource() && this.stack.length > 0)
+                this.pop();
+        }
+        if (this.context !== this.root) {
+            this.panicBlock(`Unexpected end of the source string while parsing "${this.context.node.name}" (${this.context.index}) node.`);
+        }
+        return this.root;
+    }
+    pop() {
+        const parentContext = this.stack.pop();
+        this.context.fireOnPop();
+        if (parentContext) {
+            parentContext.fireAfterChildParse(this.context);
+            parentContext.fireAbsorb(this.context);
+            this.context.cleanup();
+            const node = this.context.node;
+            this.context = parentContext;
+            if (parentContext.popsAfterNode.includes(node)) {
+                this.pop();
+            }
+        }
+        else {
+            this.context.cleanup();
+        }
+    }
+    pushNewContext(newNode, content) {
+        this.index++;
+        const ctx = newNode.createContext(this.index, this.stack.length + 1, this);
+        ctx.content = content;
+        this.context.fireBeforeChildParse(ctx);
+        this.context.pushChild(ctx);
+        this.stack.push(this.context);
+        this.hoistManager.addHoistOptions(this.context);
+        this.context = ctx;
+        return ctx;
+    }
+    fromStack(depth = 0) {
+        return this.stack[this.stack.length - depth - 1];
+    }
+    jump(n = 1) {
+        this.pos += n;
+        this.behind = this.src.slice(0, this.pos);
+        this.here = this.src.slice(this.pos, this.l);
+        return this.pos;
+    }
+    getCallbackData(matched) {
+        return {
+            parserContext: this,
+            context: this.context,
+            matched,
+            customData: this.context.getCustomData(),
+        };
+    }
+    getPosition(offset = 0) {
+        var _a;
+        const past = this.src.slice(0, this.pos + offset).split('\n');
+        const row = past.length;
+        const col = ((_a = past.pop()) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        return {
+            row, col, pos: this.pos,
+        };
+    }
+    panic(message, errorBackOffset = 0) {
+        if (this.pos > 0) {
+            const { row, col } = this.getPosition(-errorBackOffset);
+            console.error(banner$1 + '', message, '');
+            console.log(this.context.toTree({ childrenLimit: 5, showLast: true, level: 1 }));
+            console.error(renderCodeFragment(this.src.split('\n'), {
+                row: row,
+                error: col,
+            }));
+        }
+        throw new Error(message);
+    }
+    panicBlock(message, topBackOffset = 0, bottomBackOffset = 0) {
+        if (this.pos > 0) {
+            const { row, col } = this.getPosition(-bottomBackOffset);
+            console.error(banner$1 + '', message, '');
+            console.log(this.context.toTree({ childrenLimit: 13, showLast: true, level: 12 }));
+            console.error(renderCodeFragment(this.src.split('\n'), {
+                row: this.context.startPos.row,
+                error: this.context.startPos.col - topBackOffset,
+                rowEnd: row,
+                errorEnd: col,
+            }));
+        }
+        throw new Error(message);
+    }
+}
+
+const styles = {
+    banner: (s) => '' + s + '',
+    text: (s) => '' + s + '',
+    valuesDim: (s) => '' + '' + s + '' + '',
+    boolean: (s) => '' + s + '',
+    booleanDim: (s) => '' + '' + s + '' + '',
+    underscore: (s) => '' + s + '',
+    values: (s) => (typeof s === 'string' ? '' : '') + cut(s.toString(), 30) + '',
+    nodeDim: (s) => '' + '' + s + '' + '',
+    node: (s) => '' + s + '',
+};
+const stringOutputLimit = 70;
+const parserTree = new ProstoTree({
+    children: 'content',
+    renderLabel: (context) => {
+        if (typeof context === 'string') {
+            return styles.text('«' + cut(context, stringOutputLimit) + '' + '»');
+        }
+        else if (typeof context === 'object' && context instanceof ProstoParserNodeContext) {
+            let keys = '';
+            const data = context.getCustomData();
+            Object.keys(data).forEach(key => {
+                const val = data[key];
+                if (typeof val === 'string' || typeof val === 'number') {
+                    keys += ' ' + styles.valuesDim(key + '(') + styles.values(val) + styles.valuesDim(')');
+                }
+                else if (Array.isArray(val)) {
+                    keys += ' ' + styles.valuesDim(key + `[${val.length}]`);
+                }
+                else if (typeof val === 'object') {
+                    keys += ' ' + styles.valuesDim(`{ ${key} }`);
+                }
+                else if (typeof val === 'boolean' && val) {
+                    const st = key ? styles.boolean : styles.booleanDim;
+                    keys += ' ' + `${styles.underscore(st(key))}${st(val ? '☑' : '☐')}`;
+                }
+            });
+            return styles.node(context.icon + (context.label ? ' ' : '')) + styles.nodeDim(context.label) + keys;
+        }
+        return '';
+    },
+});
+function cut(s, n) {
+    const c = s.replace(/\n/g, '\\n');
+    if (c.length <= n)
+        return c;
+    return c.slice(0, n) + '' + '…';
+}
+
+class ProstoParserNodeContext extends ProstoParserNodeBase {
+    constructor(_node, index, level, parserContext) {
+        super();
+        this._node = _node;
+        this.index = index;
+        this.level = level;
+        this.content = [];
+        this._customData = {};
+        this.hasNodes = [];
+        this.count = {};
+        this.mapContentRules = {
+            'first': (content) => content[0],
+            'shift': (content) => content.shift(),
+            'pop': (content) => content.pop(),
+            'last': (content) => content[content.length - 1],
+            'join': (content) => content.join(''),
+            'join-clear': (content) => content.splice(0).join(''),
+            'copy': (content) => content,
+        };
+        this.options = _node.getOptions();
+        if (this.options.initCustomData) {
+            this._customData = this.options.initCustomData();
+        }
+        this._label = this.options.label || '';
+        this._icon = this.options.icon || '◦';
+        this.parserContext = parserContext || new ProstoParserContext(this);
+        if (parserContext) {
+            this.parent = parserContext.context || parserContext.root;
+        }
+        this.startPos = this.parserContext.getPosition();
+        this.endPos = this.parserContext.getPosition();
+    }
+    getOptions() {
+        return this.options;
+    }
+    extractCustomDataTree() {
+        let content = this.content;
+        if (this.contentCopiedTo) {
+            content = this.customData[this.contentCopiedTo];
+        }
+        if (Array.isArray(content)) {
+            return content.map(c => {
+                if (typeof c === 'string') {
+                    return c;
+                }
+                else {
+                    return extract(c);
+                }
+            });
+        }
+        else {
+            const c = content;
+            if (c instanceof ProstoParserNodeContext) {
+                return extract(c);
+            }
+            else {
+                return content;
+            }
+        }
+        function extract(c) {
+            const cd = { ...c.getCustomData() };
+            if (c.contentCopiedTo) {
+                cd[c.contentCopiedTo] = c.extractCustomDataTree();
+            }
+            return cd;
+        }
+    }
+    getPrevNode(n = 1) {
+        if (this.parent) {
+            const index = this.parent.content.findIndex(n => n === this) - n;
+            if (index >= 0)
+                return this.parent.content[index];
+        }
+    }
+    getPrevContext(n = 1) {
+        if (this.parent) {
+            const contexts = this.parent.content.filter(n => n instanceof ProstoParserNodeContext);
+            const index = contexts.findIndex(n => n === this) - n;
+            if (index >= 0)
+                return contexts[index];
+        }
+    }
+    set icon(value) {
+        this._icon = value;
+    }
+    get icon() {
+        return this._icon;
+    }
+    set label(value) {
+        this._label = value;
+    }
+    get label() {
+        return this._label;
+    }
+    getCustomData() {
+        return this._customData;
+    }
+    get customData() {
+        return this._customData;
+    }
+    get nodeId() {
+        return this._node.id;
+    }
+    get node() {
+        return this._node;
+    }
+    toTree(options) {
+        return parserTree.render(this, options);
+    }
+    getSearchTokens() {
+        var _a;
+        const rg = this.getEndTokenRg();
+        const tokens = rg ? [{
+                rg,
+                y: addFlag(rg, 'y'),
+                g: addFlag(rg, 'g'),
+            }] : [];
+        (_a = this.options.recognizes) === null || _a === void 0 ? void 0 : _a.forEach(node => {
+            const rg = node.getStartTokenRg();
+            if (rg) {
+                tokens.push({
+                    rg,
+                    y: addFlag(rg, 'y'),
+                    g: addFlag(rg, 'g'),
+                    node,
+                });
+            }
+        });
+        function addFlag(rg, f) {
+            return new RegExp(rg.source, rg.flags + f);
+        }
+        return tokens;
+    }
+    appendContent(input) {
+        let s = input;
+        this.endPos = this.parserContext.getPosition();
+        let { skip, bad } = this.getConstraintTokens();
+        skip = skip ? new RegExp(skip.source, skip.flags + 'g') : skip;
+        bad = bad ? new RegExp(bad.source, bad.flags + 'g') : bad;
+        if (skip) {
+            s = s.replace(skip, '');
+        }
+        if (bad) {
+            const m = bad.exec(s);
+            if (m) {
+                this.parserContext.jump(m.index);
+                this.parserContext.panic(`The token "${m[0].replace(/"/g, '\\"')}" is not allowed in "${this.node.name}".`);
+            }
+        }
+        s = this.fireOnAppendContent(s);
+        if (s) {
+            this.content.push(s);
+        }
+    }
+    cleanup() {
+        this.options = null;
+    }
+    pushChild(child) {
+        const absorbRule = this.options.absorbs && this.options.absorbs[child.node.id];
+        if (!absorbRule) {
+            this.content.push(child);
+        }
+    }
+    fireAbsorb(child) {
+        const absorbRule = this.options.absorbs && this.options.absorbs[child.node.id];
+        if (absorbRule) {
+            switch (absorbRule) {
+                case 'append':
+                    this.content.push(...child.content);
+                    break;
+                case 'join':
+                    this.appendContent(child.content.join(''));
+                    break;
+                default:
+                    const [action, target] = absorbRule.split('->');
+                    const cd = this.getCustomData();
+                    if (action === 'copy') {
+                        cd[target] = child.content;
+                    }
+                    else if (action === 'join') {
+                        cd[target] = child.content.join('');
+                    }
+                    else {
+                        this.parserContext.panic(`Absorb action "${action}" is not supported.`);
+                    }
+            }
+        }
+    }
+    has(node) {
+        return this.hasNodes.includes(node);
+    }
+    countOf(node) {
+        return this.count[node.id] || 0;
+    }
+    mapNamedGroups(matched) {
+        if (matched.groups) {
+            const cd = this.getCustomData();
+            for (const [key, value] of Object.entries(matched.groups)) {
+                if (key === 'content') {
+                    this.appendContent(value);
+                }
+                else {
+                    cd[key] = value;
+                }
+            }
+        }
+    }
+    fireOnPop() {
+        this.endPos = this.parserContext.getPosition();
+        this.processMappings();
+        const data = this.parserContext.getCallbackData();
+        this.node.beforeOnPop(data);
+        if (this.options.onPop) {
+            this.options.onPop(data);
+        }
+    }
+    fireOnMatch(matched) {
+        this.mapNamedGroups(matched);
+        const data = this.parserContext.getCallbackData(matched);
+        this.node.beforeOnMatch(data);
+        if (this.options.onMatch) {
+            return this.options.onMatch(data);
+        }
+    }
+    fireBeforeChildParse(child) {
+        const data = this.parserContext.getCallbackData();
+        this.node.beforeOnBeforeChildParse(child, data);
+        if (this.options.onBeforeChildParse) {
+            return this.options.onBeforeChildParse(child, data);
+        }
+    }
+    fireAfterChildParse(child) {
+        if (!this.hasNodes.includes(child.node)) {
+            this.hasNodes.push(child.node);
+        }
+        this.count[child.node.id] = this.count[child.node.id] || 0;
+        this.count[child.node.id]++;
+        const data = this.parserContext.getCallbackData();
+        this.node.beforeOnAfterChildParse(child, data);
+        if (this.options.onAfterChildParse) {
+            return this.options.onAfterChildParse(child, data);
+        }
+    }
+    fireOnAppendContent(s) {
+        let _s = s;
+        const data = this.parserContext.getCallbackData();
+        _s = this.node.beforeOnAppendContent(_s, data);
+        if (this.options.onAppendContent) {
+            _s = this.options.onAppendContent(_s, data);
+        }
+        return _s;
+    }
+    processMappings() {
+        this.parserContext.hoistManager.removeHoistOptions(this);
+        this.parserContext.hoistManager.processHoistOptions(this);
+        this.processMapContent();
+    }
+    processMapContent() {
+        const targetNodeOptions = this.options;
+        if (targetNodeOptions.mapContent) {
+            Object.keys(targetNodeOptions.mapContent).forEach((key) => {
+                const keyOfT = key;
+                if (targetNodeOptions.mapContent && targetNodeOptions.mapContent[keyOfT]) {
+                    const mapRule = targetNodeOptions.mapContent[keyOfT];
+                    if (typeof mapRule === 'function') {
+                        this._customData[keyOfT] = mapRule(this.content);
+                    }
+                    else {
+                        const ruleKey = mapRule;
+                        if (ruleKey === 'copy')
+                            this.contentCopiedTo = keyOfT;
+                        this._customData[keyOfT] = this.mapContentRules[ruleKey](this.content);
+                    }
+                    if (!this.contentCopiedTo && (typeof mapRule === 'function' || ['first', 'shift', 'pop', 'last'].includes(mapRule))) {
+                        this.contentCopiedTo = keyOfT;
+                    }
+                }
+            });
+        }
+    }
+}
+
+let idCounter = 0;
+class ProstoParserNode extends ProstoParserNodeBase {
+    constructor(options) {
+        super();
+        this.options = options;
+        this.id = idCounter++;
+    }
+    getOptions() {
+        return {
+            label: this.options.label || '',
+            icon: this.options.icon || '',
+            startsWith: (this.options.startsWith ? { ...this.options.startsWith } : this.options.startsWith),
+            endsWith: (this.options.endsWith ? { ...this.options.endsWith } : this.options.endsWith),
+            popsAfterNode: [...(this.options.popsAfterNode || [])],
+            popsAtEOFSource: this.options.popsAtEOFSource || false,
+            badToken: this.options.badToken || '',
+            skipToken: this.options.skipToken || '',
+            recognizes: [...(this.options.recognizes || [])],
+            hoistChildren: [...(this.options.hoistChildren || [])],
+            mapContent: {
+                ...this.options.mapContent,
+            },
+            onPop: this.options.onPop,
+            onMatch: this.options.onMatch,
+            onAppendContent: this.options.onAppendContent,
+            onAfterChildParse: this.options.onAfterChildParse,
+            onBeforeChildParse: this.options.onBeforeChildParse,
+            initCustomData: this.options.initCustomData,
+            absorbs: this.options.absorbs,
+        };
+    }
+    createContext(index, level, rootContext) {
+        return new ProstoParserNodeContext(this, index, level, rootContext);
+    }
+    get name() {
+        return this.constructor.name + '[' + this.id.toString() + ']' + '(' + (this.options.label || this.options.icon || '') + ')';
+    }
+    parse(source) {
+        return this.createContext(0, 0).parserContext.parse(source);
+    }
+    beforeOnPop(data) {
+    }
+    beforeOnMatch(data) {
+    }
+    beforeOnAppendContent(s, data) {
+        return s;
+    }
+    beforeOnAfterChildParse(child, data) {
+    }
+    beforeOnBeforeChildParse(child, data) {
+    }
+}
+
+class BasicNode extends ProstoParserNode {
+    constructor(options) {
+        var _a, _b;
+        const startsWith = (options === null || options === void 0 ? void 0 : options.tokens) ? { token: options === null || options === void 0 ? void 0 : options.tokens[0] } : undefined;
+        const endsWith = (options === null || options === void 0 ? void 0 : options.tokens) ? { token: options === null || options === void 0 ? void 0 : options.tokens[1] } : undefined;
+        const [startOption, endOption] = ((_a = options.tokenOE) === null || _a === void 0 ? void 0 : _a.split('-')) || [];
+        const [startBSlash, endBSlash] = ((_b = options.backSlash) === null || _b === void 0 ? void 0 : _b.split('-')) || [];
+        if (startsWith) {
+            startsWith.omit = startOption === 'omit';
+            startsWith.eject = startOption === 'eject';
+            startsWith.ignoreBackSlashed = startBSlash === 'ignore';
+        }
+        if (endsWith) {
+            endsWith.omit = endOption === 'omit';
+            endsWith.eject = endOption === 'eject';
+            endsWith.ignoreBackSlashed = endBSlash === 'ignore';
+        }
+        super({
+            icon: options.icon || '',
+            label: typeof options.label === 'string' ? options.label : '',
+            startsWith,
+            endsWith,
+            badToken: options.badToken,
+            skipToken: options.skipToken,
+        });
+        if (options.recursive) {
+            this.addAbsorbs(this, 'join');
+        }
+    }
+}
+
+class ParametricNodeWithRegex extends BasicNode {
+    constructor(options, rgNode) {
+        super(options);
+        const hoistRegex = {
+            as: 'regex',
+            node: regexNode,
+            onConflict: 'overwrite',
+            removeChildFromContent: true,
+            deep: 1,
+            mapRule: ({ content }) => content.join('').replace(/^\(\^/, '(').replace(/\$\)$/, ')'),
+        };
+        this.mapContent('value', content => content.shift())
+            .popsAtEOFSource(true)
+            .addRecognizes(rgNode)
+            .addPopsAfterNode(rgNode)
+            .addHoistChildren(hoistRegex);
+    }
+}
+const regexNode = new BasicNode({
+    label: 'RegEx',
+    tokens: ['(', ')'],
+    backSlash: 'ignore-ignore',
+    recursive: true,
+}).onMatch(({ parserContext, context }) => {
+    var _a;
+    if (((_a = parserContext.fromStack()) === null || _a === void 0 ? void 0 : _a.node) === context.node) {
+        if (!parserContext.here.startsWith('?:')) {
+            context.content[0] += '?:';
+        }
+    }
+});
+const paramNode = new ParametricNodeWithRegex({
+    label: 'Parameter',
+    tokens: [':', /[\/\-]/],
+    tokenOE: 'omit-eject',
+    backSlash: 'ignore-',
+}, regexNode).initCustomData(() => ({ type: EPathSegmentType.VARIABLE, value: '', regex: '([^\\/]*)' }));
+const wildcardNode = new ParametricNodeWithRegex({
+    label: 'Wildcard',
+    tokens: ['*', /[^*\()]/],
+    tokenOE: '-eject',
+}, regexNode).initCustomData(() => ({ type: EPathSegmentType.WILDCARD, value: '*', regex: '(.*)' }));
+const staticNode = new BasicNode({
+    label: 'Static',
+    tokens: [/[^:\*]/, /[:\*]/],
+    backSlash: '-ignore',
+    tokenOE: '-eject',
+}).initCustomData(() => ({ type: EPathSegmentType.STATIC, value: '' }))
+    .mapContent('value', content => content.splice(0).join('').replace(/\\:/g, ':'))
+    .popsAtEOFSource(true);
+new BasicNode({}).addRecognizes(staticNode, paramNode, wildcardNode);
+
+var EPathSegmentType;
+(function (EPathSegmentType) {
+    EPathSegmentType[EPathSegmentType["STATIC"] = 0] = "STATIC";
+    EPathSegmentType[EPathSegmentType["VARIABLE"] = 1] = "VARIABLE";
+    EPathSegmentType[EPathSegmentType["REGEX"] = 2] = "REGEX";
+    EPathSegmentType[EPathSegmentType["WILDCARD"] = 3] = "WILDCARD";
+})(EPathSegmentType || (EPathSegmentType = {}));
+
+function useHttpContext() {
+    return eventCore.useEventContext('HTTP');
+}
+
+const httpStatusCodes = {
+    [100]: 'Continue',
+    [101]: 'Switching protocols',
+    [102]: 'Processing',
+    [103]: 'Early Hints',
+    [200]: 'OK',
+    [201]: 'Created',
+    [202]: 'Accepted',
+    [203]: 'Non-Authoritative Information',
+    [204]: 'No Content',
+    [205]: 'Reset Content',
+    [206]: 'Partial Content',
+    [207]: 'Multi-Status',
+    [208]: 'Already Reported',
+    [226]: 'IM Used',
+    [300]: 'Multiple Choices',
+    [301]: 'Moved Permanently',
+    [302]: 'Found (Previously "Moved Temporarily")',
+    [303]: 'See Other',
+    [304]: 'Not Modified',
+    [305]: 'Use Proxy',
+    [306]: 'Switch Proxy',
+    [307]: 'Temporary Redirect',
+    [308]: 'Permanent Redirect',
+    [400]: 'Bad Request',
+    [401]: 'Unauthorized',
+    [402]: 'Payment Required',
+    [403]: 'Forbidden',
+    [404]: 'Not Found',
+    [405]: 'Method Not Allowed',
+    [406]: 'Not Acceptable',
+    [407]: 'Proxy Authentication Required',
+    [408]: 'Request Timeout',
+    [409]: 'Conflict',
+    [410]: 'Gone',
+    [411]: 'Length Required',
+    [412]: 'Precondition Failed',
+    [413]: 'Payload Too Large',
+    [414]: 'URI Too Long',
+    [415]: 'Unsupported Media Type',
+    [416]: 'Range Not Satisfiable',
+    [417]: 'Expectation Failed',
+    [418]: 'I\'m a Teapot',
+    [421]: 'Misdirected Request',
+    [422]: 'Unprocessable Entity',
+    [423]: 'Locked',
+    [424]: 'Failed Dependency',
+    [425]: 'Too Early',
+    [426]: 'Upgrade Required',
+    [428]: 'Precondition Required',
+    [429]: 'Too Many Requests',
+    [431]: 'Request Header Fields Too Large',
+    [451]: 'Unavailable For Legal Reasons',
+    [500]: 'Internal Server Error',
+    [501]: 'Not Implemented',
+    [502]: 'Bad Gateway',
+    [503]: 'Service Unavailable',
+    [504]: 'Gateway Timeout',
+    [505]: 'HTTP Version Not Supported',
+    [506]: 'Variant Also Negotiates',
+    [507]: 'Insufficient Storage',
+    [508]: 'Loop Detected',
+    [510]: 'Not Extended',
+    [511]: 'Network Authentication Required',
+};
+var EHttpStatusCode;
+(function (EHttpStatusCode) {
+    EHttpStatusCode[EHttpStatusCode["Continue"] = 100] = "Continue";
+    EHttpStatusCode[EHttpStatusCode["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+    EHttpStatusCode[EHttpStatusCode["Processing"] = 102] = "Processing";
+    EHttpStatusCode[EHttpStatusCode["EarlyHints"] = 103] = "EarlyHints";
+    EHttpStatusCode[EHttpStatusCode["OK"] = 200] = "OK";
+    EHttpStatusCode[EHttpStatusCode["Created"] = 201] = "Created";
+    EHttpStatusCode[EHttpStatusCode["Accepted"] = 202] = "Accepted";
+    EHttpStatusCode[EHttpStatusCode["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+    EHttpStatusCode[EHttpStatusCode["NoContent"] = 204] = "NoContent";
+    EHttpStatusCode[EHttpStatusCode["ResetContent"] = 205] = "ResetContent";
+    EHttpStatusCode[EHttpStatusCode["PartialContent"] = 206] = "PartialContent";
+    EHttpStatusCode[EHttpStatusCode["MultiStatus"] = 207] = "MultiStatus";
+    EHttpStatusCode[EHttpStatusCode["AlreadyReported"] = 208] = "AlreadyReported";
+    EHttpStatusCode[EHttpStatusCode["IMUsed"] = 226] = "IMUsed";
+    EHttpStatusCode[EHttpStatusCode["MultipleChoices"] = 300] = "MultipleChoices";
+    EHttpStatusCode[EHttpStatusCode["MovedPermanently"] = 301] = "MovedPermanently";
+    EHttpStatusCode[EHttpStatusCode["Found"] = 302] = "Found";
+    EHttpStatusCode[EHttpStatusCode["SeeOther"] = 303] = "SeeOther";
+    EHttpStatusCode[EHttpStatusCode["NotModified"] = 304] = "NotModified";
+    EHttpStatusCode[EHttpStatusCode["UseProxy"] = 305] = "UseProxy";
+    EHttpStatusCode[EHttpStatusCode["SwitchProxy"] = 306] = "SwitchProxy";
+    EHttpStatusCode[EHttpStatusCode["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+    EHttpStatusCode[EHttpStatusCode["PermanentRedirect"] = 308] = "PermanentRedirect";
+    EHttpStatusCode[EHttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    EHttpStatusCode[EHttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    EHttpStatusCode[EHttpStatusCode["PaymentRequired"] = 402] = "PaymentRequired";
+    EHttpStatusCode[EHttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    EHttpStatusCode[EHttpStatusCode["NotFound"] = 404] = "NotFound";
+    EHttpStatusCode[EHttpStatusCode["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    EHttpStatusCode[EHttpStatusCode["NotAcceptable"] = 406] = "NotAcceptable";
+    EHttpStatusCode[EHttpStatusCode["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+    EHttpStatusCode[EHttpStatusCode["RequestTimeout"] = 408] = "RequestTimeout";
+    EHttpStatusCode[EHttpStatusCode["Conflict"] = 409] = "Conflict";
+    EHttpStatusCode[EHttpStatusCode["Gone"] = 410] = "Gone";
+    EHttpStatusCode[EHttpStatusCode["LengthRequired"] = 411] = "LengthRequired";
+    EHttpStatusCode[EHttpStatusCode["PreconditionFailed"] = 412] = "PreconditionFailed";
+    EHttpStatusCode[EHttpStatusCode["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+    EHttpStatusCode[EHttpStatusCode["URITooLong"] = 414] = "URITooLong";
+    EHttpStatusCode[EHttpStatusCode["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+    EHttpStatusCode[EHttpStatusCode["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+    EHttpStatusCode[EHttpStatusCode["ExpectationFailed"] = 417] = "ExpectationFailed";
+    EHttpStatusCode[EHttpStatusCode["ImATeapot"] = 418] = "ImATeapot";
+    EHttpStatusCode[EHttpStatusCode["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+    EHttpStatusCode[EHttpStatusCode["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+    EHttpStatusCode[EHttpStatusCode["Locked"] = 423] = "Locked";
+    EHttpStatusCode[EHttpStatusCode["FailedDependency"] = 424] = "FailedDependency";
+    EHttpStatusCode[EHttpStatusCode["TooEarly"] = 425] = "TooEarly";
+    EHttpStatusCode[EHttpStatusCode["UpgradeRequired"] = 426] = "UpgradeRequired";
+    EHttpStatusCode[EHttpStatusCode["PreconditionRequired"] = 428] = "PreconditionRequired";
+    EHttpStatusCode[EHttpStatusCode["TooManyRequests"] = 429] = "TooManyRequests";
+    EHttpStatusCode[EHttpStatusCode["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+    EHttpStatusCode[EHttpStatusCode["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+    EHttpStatusCode[EHttpStatusCode["InternalServerError"] = 500] = "InternalServerError";
+    EHttpStatusCode[EHttpStatusCode["NotImplemented"] = 501] = "NotImplemented";
+    EHttpStatusCode[EHttpStatusCode["BadGateway"] = 502] = "BadGateway";
+    EHttpStatusCode[EHttpStatusCode["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    EHttpStatusCode[EHttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+    EHttpStatusCode[EHttpStatusCode["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
+    EHttpStatusCode[EHttpStatusCode["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+    EHttpStatusCode[EHttpStatusCode["InsufficientStorage"] = 507] = "InsufficientStorage";
+    EHttpStatusCode[EHttpStatusCode["LoopDetected"] = 508] = "LoopDetected";
+    EHttpStatusCode[EHttpStatusCode["NotExtended"] = 510] = "NotExtended";
+    EHttpStatusCode[EHttpStatusCode["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+})(EHttpStatusCode || (EHttpStatusCode = {}));
+
+({
+    GET: EHttpStatusCode.OK,
+    POST: EHttpStatusCode.Created,
+    PUT: EHttpStatusCode.Created,
+    PATCH: EHttpStatusCode.Accepted,
+    DELETE: EHttpStatusCode.Accepted,
+});
+
+class WooksError extends Error {
+    constructor(code = 500, _body = '') {
+        super(typeof _body === 'string' ? _body : _body.message);
+        this.code = code;
+        this._body = _body;
+    }
+    get body() {
+        return typeof this._body === 'string' ? {
+            statusCode: this.code,
+            message: this.message,
+            error: httpStatusCodes[this.code],
+        } : Object.assign(Object.assign({}, this._body), { statusCode: this.code, message: this.message, error: httpStatusCodes[this.code] });
+    }
+    attachRenderer(renderer) {
+        this.renderer = renderer;
+    }
+    getRenderer() {
+        return this.renderer;
+    }
+}
+
+const METADATA_WORKSPACE = 'moost';
+const moostMate = new mate.Mate(METADATA_WORKSPACE, {
+    readType: true,
+    readReturnType: true,
+});
+function getMoostMate() {
+    return moostMate;
+}
+
+function getInstanceOwnMethods(instance) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const proto = Object.getPrototypeOf(instance);
+    return [
+        ...Object.getOwnPropertyNames(proto),
+        ...Object.getOwnPropertyNames(instance),
+    ].filter(m => typeof instance[m] === 'function');
+}
+
+const banner = () => `[${"moost"}][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
+
+/* istanbul ignore file */
+function log(text) {
+    console.log('' + '' + banner() + text + '');
+}
+function logError(error) {
+    console.error('' + '' + banner() + error + '');
+}
+
+function panic(error) {
+    logError(error);
+    return new Error(error);
+}
+
+function runPipes(pipes, meta, restoreCtx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let v = undefined;
+        for (const pipe of pipes) {
+            restoreCtx && restoreCtx();
+            v = yield pipe.handler(v, meta);
+        }
+        return v;
+    });
+}
+
+exports.TPipePriority = void 0;
+(function (TPipePriority) {
+    TPipePriority[TPipePriority["BEFORE_RESOLVE"] = 0] = "BEFORE_RESOLVE";
+    TPipePriority[TPipePriority["RESOLVE"] = 1] = "RESOLVE";
+    TPipePriority[TPipePriority["AFTER_RESOLVE"] = 2] = "AFTER_RESOLVE";
+    TPipePriority[TPipePriority["BEFORE_TRANSFORM"] = 3] = "BEFORE_TRANSFORM";
+    TPipePriority[TPipePriority["TRANSFORM"] = 4] = "TRANSFORM";
+    TPipePriority[TPipePriority["AFTER_TRANSFORM"] = 5] = "AFTER_TRANSFORM";
+    TPipePriority[TPipePriority["BEFORE_VALIDATE"] = 6] = "BEFORE_VALIDATE";
+    TPipePriority[TPipePriority["VALIDATE"] = 7] = "VALIDATE";
+    TPipePriority[TPipePriority["AFTER_VALIDATE"] = 8] = "AFTER_VALIDATE";
+})(exports.TPipePriority || (exports.TPipePriority = {}));
+
+const resolvePipe = (_value, meta) => {
+    if (meta === null || meta === void 0 ? void 0 : meta.resolver) {
+        return meta.resolver();
+    }
+    return undefined;
+};
+resolvePipe.priority = exports.TPipePriority.RESOLVE;
+
+const sharedPipes = [
+    {
+        handler: resolvePipe,
+        priority: exports.TPipePriority.RESOLVE,
+    },
+];
+
+const sharedMoostInfact = getNewMoostInfact();
+function getMoostInfact() {
+    return sharedMoostInfact;
+}
+function getNewMoostInfact() {
+    return new infact.Infact({
+        describeClass(classConstructor) {
+            const meta = getMoostMate().read(classConstructor);
+            const infactMeta = {
+                injectable: !!(meta === null || meta === void 0 ? void 0 : meta.injectable),
+                global: false,
+                constructorParams: (meta === null || meta === void 0 ? void 0 : meta.params) || [],
+                provide: meta === null || meta === void 0 ? void 0 : meta.provide,
+                scopeId: (meta === null || meta === void 0 ? void 0 : meta.injectable) === 'FOR_EVENT' ? eventCore.useEventId().getId() : undefined,
+            };
+            return infactMeta;
+        },
+        resolveParam(paramMeta) {
+            if (paramMeta.resolver) {
+                return runPipes(sharedPipes, paramMeta);
+            }
+        },
+        storeProvideRegByInstance: true,
+    });
+}
+
+function getCallableFn(targetInstance, fn, restoreCtx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mate$1 = getMoostMate();
+        const meta = mate$1.read(fn);
+        if (meta === null || meta === void 0 ? void 0 : meta.injectable) {
+            const infact = getMoostInfact();
+            infact.silent(meta.injectable === 'FOR_EVENT');
+            const instance = yield infact.getForInstance(targetInstance, fn, [], () => { restoreCtx && restoreCtx(); });
+            infact.silent(false);
+            return ((...args) => {
+                return instance.handler(...args);
+            });
+        }
+        if (typeof fn === 'function') {
+            return fn;
+        }
+        throw panic(`getCallableFn failed for "${mate.getConstructor(targetInstance).name}" because the passed arg is not a Function nor TClassFunction`);
+    });
+}
+
+class InterceptorHandler {
+    constructor(handlers) {
+        this.handlers = handlers;
+        this.before = [];
+        this.after = [];
+        this.onError = [];
+        this.responseOverwritten = false;
+    }
+    replyFn(reply) {
+        this.response = reply;
+        this.responseOverwritten = true;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { restoreCtx } = eventCore.useEventContext();
+            for (const handler of this.handlers) {
+                restoreCtx();
+                yield handler((fn) => { this.before.push(fn); }, (fn) => { this.after.unshift(fn); }, (fn) => { this.onError.unshift(fn); });
+            }
+        });
+    }
+    fireBefore(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { restoreCtx } = eventCore.useEventContext();
+            this.response = response;
+            for (const handler of this.before) {
+                restoreCtx();
+                yield handler(this.replyFn.bind(this));
+                if (this.responseOverwritten)
+                    break;
+            }
+            return this.response;
+        });
+    }
+    fireAfter(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { restoreCtx } = eventCore.useEventContext();
+            this.response = response;
+            if (response instanceof Error) {
+                for (const handler of this.onError) {
+                    restoreCtx();
+                    yield handler(response, this.replyFn.bind(this));
+                }
+            }
+            else {
+                for (const handler of this.after) {
+                    restoreCtx();
+                    yield handler(response, this.replyFn.bind(this));
+                }
+            }
+            return this.response;
+        });
+    }
+}
+
+function bindControllerMethods(options) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const opts = options || {};
+        const { getInstance } = opts;
+        const { classConstructor } = opts;
+        const { adapters } = opts;
+        opts.globalPrefix = opts.globalPrefix || '';
+        opts.provide = opts.provide || {};
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const fakeInstance = Object.create(classConstructor.prototype);
+        const methods = getInstanceOwnMethods(fakeInstance);
+        const mate = getMoostMate();
+        const meta = mate.read(classConstructor) || {};
+        const ownPrefix = typeof opts.replaceOwnPrefix === 'string' ? opts.replaceOwnPrefix : (((_a = meta.controller) === null || _a === void 0 ? void 0 : _a.prefix) || '');
+        const prefix = `${opts.globalPrefix}/${ownPrefix}`;
+        for (const method of methods) {
+            const methodMeta = getMoostMate().read(fakeInstance, method) || {};
+            if (!methodMeta.handlers || !methodMeta.handlers.length)
+                continue;
+            // preparing interceptors
+            const interceptors = [...(opts.interceptors || []), ...(meta.interceptors || []), ...(methodMeta.interceptors || [])].sort((a, b) => a.priority - b.priority);
+            const getIterceptorHandler = () => __awaiter(this, void 0, void 0, function* () {
+                const interceptorHandlers = [];
+                for (const { handler } of interceptors) {
+                    const interceptorMeta = mate.read(handler);
+                    if (interceptorMeta === null || interceptorMeta === void 0 ? void 0 : interceptorMeta.injectable) {
+                        interceptorHandlers.push((...args) => __awaiter(this, void 0, void 0, function* () {
+                            const { restoreCtx } = useHttpContext();
+                            const targetInstance = yield getInstance();
+                            restoreCtx();
+                            return (yield getCallableFn(targetInstance, handler, restoreCtx))(...args);
+                        }));
+                    }
+                    else {
+                        interceptorHandlers.push(handler);
+                    }
+                }
+                return new InterceptorHandler(interceptorHandlers);
+            });
+            // preparing pipes
+            const pipes = [...(opts.pipes || []), ...(meta.pipes || []), ...(methodMeta.pipes || [])];
+            const argsPipes = [];
+            for (const p of methodMeta.params || []) {
+                argsPipes.push({
+                    meta: p,
+                    pipes: [...pipes, ...(p.pipes || [])].sort((a, b) => a.priority - b.priority),
+                });
+            }
+            const resolveArgs = () => __awaiter(this, void 0, void 0, function* () {
+                const args = [];
+                const { restoreCtx } = eventCore.useEventContext();
+                for (let i = 0; i < argsPipes.length; i++) {
+                    const { pipes, meta } = argsPipes[i];
+                    args[i] = yield runPipes(pipes, meta, restoreCtx);
+                }
+                return args;
+            });
+            // preparing provide
+            // const provide = {...(opts.provide || {}), ...(meta.provide || {})}
+            for (const adapter of adapters) {
+                yield adapter.bindHandler({
+                    prefix,
+                    fakeInstance,
+                    getInstance,
+                    registerEventScope: (scopeId) => {
+                        const infact = getMoostInfact();
+                        infact.registerScope(scopeId);
+                        return () => infact.unregisterScope(scopeId);
+                    },
+                    method,
+                    handlers: methodMeta.handlers,
+                    getIterceptorHandler,
+                    resolveArgs,
+                    logHandler: (eventName) => log(`• ${eventName} ${'' + '' + ''}→ ${classConstructor.name}.${''}${method}${''}()`),
+                });
+            }
+        }
+    });
+}
+
+function Label(value) {
+    return getMoostMate().decorate('label', value);
+}
+function Id(value) {
+    return getMoostMate().decorate('id', value);
+}
+function Optional() {
+    return getMoostMate().decorate('optional', true);
+}
+function Required() {
+    const mate = getMoostMate();
+    return mate.apply(mate.decorate('required', true), 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    mate.decorateClass((meta, key, index) => {
+        if (typeof index !== 'number' && meta && ['string', 'symbol'].includes(typeof key)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+            meta.requiredProps = meta.requiredProps || [];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            meta.requiredProps.push(key);
+        }
+        return meta;
+    }));
+}
+
+/**
+ * Hook to the Response Status
+ * @decorator
+ * @param resolver - resolver function
+ * @param label - field label
+ * @paramType unknown
+ */
+function Resolve(resolver, label) {
+    return (target, key, index) => {
+        fillLabel(target, key, index, label);
+        getMoostMate().decorate('resolver', resolver)(target, key, index);
+    };
+}
+/**
+ * Get Param Value from url parh
+ * @decorator
+ * @param name - param name
+ * @paramType string
+ */
+function Param(name) {
+    return Resolve(() => eventCore.useRouteParams().get(name), name);
+}
+/**
+ * Get Parsed Params from url parh
+ * @decorator
+ * @paramType object
+ */
+function Params() {
+    return Resolve(() => eventCore.useRouteParams().params, 'params');
+}
+/**
+ * Provide Const Value
+ * @decorator
+ * @param value - provided value
+ * @param label - label of the field
+ * @paramType unknown
+ */
+function Const(value, label) {
+    return Resolve(() => value, label);
+}
+function fillLabel(target, key, index, name) {
+    if (name) {
+        const meta = getMoostMate().read(target, key);
+        if (!(meta === null || meta === void 0 ? void 0 : meta.params) || !(meta === null || meta === void 0 ? void 0 : meta.params[index]) || !(meta === null || meta === void 0 ? void 0 : meta.params[index].label)) {
+            Label(name)(target, key, index);
+        }
+    }
+}
+
+/**
+ * Mark the Class as Injectable to enable it to be used in dependency injection
+ * @decorator
+ * @param scope - Scope for injection ("FOR_EVENT" | "SINGLETON" | true)
+ * FOR_EVENT - will create a new instance for each incoming request
+ * SINGLETON | true - will create a new instance only once
+ * @param label - field label
+ */
+function Injectable(scope = true) {
+    return getMoostMate().decorate('injectable', scope);
+}
+const insureInjectable = getMoostMate().decorate((meta) => {
+    if (!meta.injectable)
+        meta.injectable = true;
+    return meta;
+});
+
+/**
+ * Set Class as a Controller
+ * @decorator
+ * @param prefix - define the prefix for all the paths of this controller
+ */
+function Controller(prefix) {
+    const mate = getMoostMate();
+    return mate.apply(insureInjectable, mate.decorate('controller', { prefix: prefix || '' }));
+}
+function ImportController(prefix, controller, provide) {
+    return getMoostMate().decorate('importController', {
+        prefix: typeof prefix === 'string' ? prefix : undefined,
+        typeResolver: typeof prefix === 'string' ? controller : prefix,
+        provide: typeof prefix === 'string' ? provide || undefined : controller || undefined,
+    }, true);
+}
+
+function Circular(resolver) {
+    return getMoostMate().decorate('circular', resolver);
+}
+
+exports.TInterceptorPriority = void 0;
+(function (TInterceptorPriority) {
+    TInterceptorPriority[TInterceptorPriority["BEFORE_ALL"] = 0] = "BEFORE_ALL";
+    TInterceptorPriority[TInterceptorPriority["BEFORE_GUARD"] = 1] = "BEFORE_GUARD";
+    TInterceptorPriority[TInterceptorPriority["GUARD"] = 2] = "GUARD";
+    TInterceptorPriority[TInterceptorPriority["AFTER_GUARD"] = 3] = "AFTER_GUARD";
+    TInterceptorPriority[TInterceptorPriority["INTERCEPTOR"] = 4] = "INTERCEPTOR";
+    TInterceptorPriority[TInterceptorPriority["CATCH_ERROR"] = 5] = "CATCH_ERROR";
+    TInterceptorPriority[TInterceptorPriority["AFTER_ALL"] = 6] = "AFTER_ALL";
+})(exports.TInterceptorPriority || (exports.TInterceptorPriority = {}));
+function Intercept(handler, priority) {
+    return getMoostMate().decorate('interceptors', {
+        handler,
+        priority: priority || handler.priority || exports.TInterceptorPriority.INTERCEPTOR,
+    }, true);
+}
+
+function Provide(type, fn) {
+    return getMoostMate().decorate(meta => {
+        meta.provide = meta.provide || {};
+        Object.assign(meta.provide, infact.createProvideRegistry([type, fn]));
+        return meta;
+    });
+}
+function Inject(type) {
+    return getMoostMate().decorate('inject', type);
+}
+
+function Dto(dtoOptions = {}) {
+    return getMoostMate().decorate('dto', dtoOptions || {});
+}
+let isArrayItemValidator = false;
+function Validate(validator) {
+    return getMoostMate().decorate(isArrayItemValidator ? 'validatorsOfItem' : 'validators', validator, true);
+}
+function IsArray(opts) {
+    const mate = getMoostMate();
+    const decorators = [mate.decorate('arrayType', opts || true)];
+    if ((opts === null || opts === void 0 ? void 0 : opts.itemValidators) && !isArrayItemValidator) {
+        isArrayItemValidator = true;
+        decorators.push(...opts.itemValidators());
+        isArrayItemValidator = false;
+    }
+    else if ((opts === null || opts === void 0 ? void 0 : opts.itemValidators) && isArrayItemValidator) {
+        throw new Error('IsArray validator is not supported inside of array type');
+    }
+    const decorator = mate.apply(...decorators);
+    return decorator;
+}
+function IsTypeOf(type, errorText) {
+    return Validate(valido$1.validoIsTypeOf(type, errorText));
+}
+function IsString(...args) {
+    return Validate(valido$1.validoIsString(...args));
+}
+function IsNumber(...args) {
+    return Validate(valido$1.validoIsNumber(...args));
+}
+function IsBoolean(...args) {
+    return Validate(valido$1.validoIsBoolean(...args));
+}
+
+const valido = new valido$1.Valido({
+    getDtoMeta(value, _type) {
+        let type = _type;
+        if (!type) {
+            type = mate.getConstructor(value);
+        }
+        const mate$1 = getMoostMate();
+        return mate$1.read(type);
+    },
+    getDtoParamMeta(value, type, key) {
+        const mate = getMoostMate();
+        return mate.read(type, key);
+    },
+});
+function getMoostValido() {
+    return valido;
+}
+
+class Moost {
+    constructor(options) {
+        this.options = options;
+        this.pipes = [...sharedPipes];
+        this.interceptors = [];
+        this.adapters = [];
+        this.provide = infact.createProvideRegistry([infact.Infact, getMoostInfact], [mate.Mate, getMoostMate], [valido$1.Valido, getMoostValido]);
+        this.unregisteredControllers = [];
+    }
+    adapter(a) {
+        this.adapters.push(a);
+        return a;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setProvideRegistry(infact.createProvideRegistry([Moost, () => this]));
+            this.unregisteredControllers.unshift(this);
+            yield this.bindControllers();
+            for (const a of this.adapters) {
+                yield (a.onInit && a.onInit());
+            }
+        });
+    }
+    bindControllers() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const meta = getMoostMate();
+            const thisMeta = meta.read(this);
+            const provide = Object.assign(Object.assign({}, ((thisMeta === null || thisMeta === void 0 ? void 0 : thisMeta.provide) || {})), this.provide);
+            for (const controller of this.unregisteredControllers) {
+                yield this.bindController(controller, provide, ((_a = this.options) === null || _a === void 0 ? void 0 : _a.globalPrefix) || '');
+            }
+            this.unregisteredControllers = [];
+        });
+    }
+    bindController(controller, provide, globalPrefix, replaceOwnPrefix) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const meta = getMoostMate();
+            const classMeta = meta.read(controller);
+            const infact = getMoostInfact();
+            const isControllerConsructor = mate.isConstructor(controller);
+            let instance;
+            if (isControllerConsructor && (classMeta === null || classMeta === void 0 ? void 0 : classMeta.injectable) === 'SINGLETON') {
+                instance = (yield infact.get(controller, provide));
+            }
+            else if (!isControllerConsructor) {
+                instance = controller;
+                infact.setProvideRegByInstance(instance, provide);
+            }
+            // getInstance - instance factory for resolving SINGLETON and FOR_EVENT instance
+            const getInstance = instance ? () => Promise.resolve(instance) : () => __awaiter(this, void 0, void 0, function* () {
+                // if (!instance) {
+                infact.silent();
+                const instance = yield infact.get(controller, provide);
+                infact.silent(false);
+                // }
+                return instance;
+            });
+            const classConstructor = mate.isConstructor(controller) ? controller : mate.getConstructor(controller);
+            yield bindControllerMethods({
+                getInstance,
+                classConstructor,
+                adapters: this.adapters,
+                globalPrefix,
+                replaceOwnPrefix,
+                interceptors: [...this.interceptors],
+                pipes: [...this.pipes],
+                provide: (classMeta === null || classMeta === void 0 ? void 0 : classMeta.provide) || {},
+            });
+            if (classMeta && classMeta.importController) {
+                const prefix = typeof replaceOwnPrefix === 'string' ? replaceOwnPrefix : (_a = classMeta === null || classMeta === void 0 ? void 0 : classMeta.controller) === null || _a === void 0 ? void 0 : _a.prefix;
+                const mergedProvide = Object.assign(Object.assign({}, provide), ((classMeta === null || classMeta === void 0 ? void 0 : classMeta.provide) || {}));
+                for (const ic of classMeta.importController) {
+                    if (ic.typeResolver) {
+                        const isConstr = mate.isConstructor(ic.typeResolver);
+                        const isFunc = typeof ic.typeResolver === 'function';
+                        yield this.bindController(
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                        isConstr ? ic.typeResolver : isFunc ? yield ic.typeResolver() : ic.typeResolver, ic.provide ? Object.assign(Object.assign({}, mergedProvide), ic.provide) : mergedProvide, `${globalPrefix}/${(prefix || '')}`, ic.prefix);
+                    }
+                }
+            }
+        });
+    }
+    applyGlobalPipes(...items) {
+        for (const item of items) {
+            if (typeof item === 'function') {
+                this.pipes.push({
+                    handler: item,
+                    priority: typeof item.priority === 'number' ? item.priority : exports.TPipePriority.TRANSFORM,
+                });
+            }
+            else {
+                this.pipes.push({
+                    handler: item.handler,
+                    priority: item.priority,
+                });
+            }
+        }
+        return this;
+    }
+    applyGlobalInterceptors(...items) {
+        for (const item of items) {
+            if (typeof item === 'function') {
+                this.interceptors.push({
+                    handler: item,
+                    priority: typeof item.priority === 'number' ? item.priority : exports.TInterceptorPriority.INTERCEPTOR,
+                });
+            }
+            else {
+                this.interceptors.push({
+                    handler: item.handler,
+                    priority: item.priority,
+                });
+            }
+        }
+        return this;
+    }
+    /**
+     * Register new entried to provide as dependency injections
+     * @param provide - Provide Registry (use createProvideRegistry from '\@prostojs/infact')
+     * @returns
+     */
+    setProvideRegistry(provide) {
+        this.provide = Object.assign(Object.assign({}, this.provide), provide);
+        return this;
+    }
+    /**
+     * Register controllers (similar to @ImportController decorator)
+     * @param controllers - list of target controllers (instances)
+     * @returns
+     */
+    registerControllers(...controllers) {
+        this.unregisteredControllers.push(...controllers);
+        return this;
+    }
+}
+
+function useControllerMeta() {
+    const moostStore = useMoostStore();
+    return {
+        getClassMeta: () => getMoostMate().read(moostStore.value.controller),
+        getMethodMeta: () => getMoostMate().read(moostStore.value.controller, moostStore.value.method),
+    };
+}
+function useMoostStore() {
+    return useHttpContext().store('moost');
+}
+
+const genericTypesCastPipe = (strict) => {
+    const handler = (value, meta) => {
+        if (meta === null || meta === void 0 ? void 0 : meta.type) {
+            if ((value === undefined || value === null || (meta.type !== String && value === '')) && meta.optional) {
+                return undefined;
+            }
+            switch (meta.type) {
+                case Date: {
+                    let d;
+                    if (typeof value === 'string') {
+                        d = new Date(/^\d+$/.test(value) ? Number(value) : value);
+                    }
+                    else {
+                        d = new Date(value);
+                    }
+                    if (strict && Number.isNaN(d.getTime())) {
+                        typeError(value, 'Date', meta.label);
+                    }
+                    return Number.isNaN(d.getTime()) ? value : d;
+                }
+                case Boolean:
+                    if ([true, 'true', 'TRUE', 'True', 1, '1', 'X', 'x'].includes(value)) {
+                        return true;
+                    }
+                    if ([false, 'false', 'FALSE', 'False', 0, '0', '', ' ', null, undefined].includes(value)) {
+                        return false;
+                    }
+                    if (strict) {
+                        typeError(value, 'boolean', meta.label);
+                    }
+                    return value;
+                case Number: {
+                    if (strict && !value && value !== 0) {
+                        typeError(value, 'numeric', meta.label);
+                    }
+                    const n = typeof value === 'string' && value.length > 0 ? Number(value) : NaN;
+                    if (strict && Number.isNaN(n)) {
+                        typeError(value, 'numeric', meta.label);
+                    }
+                    return Number.isNaN(n) ? value : n;
+                }
+                case String:
+                    if (strict && ['object', 'function'].includes(typeof value)) {
+                        typeError(value, 'string', meta.label);
+                    }
+                    return value && String(value) || value;
+                default:
+                    return value;
+            }
+        }
+    };
+    handler.priority = exports.TPipePriority.AFTER_TRANSFORM;
+    return handler;
+};
+function typeError(value, targetType, label) {
+    const prefix = label ? `Argument "${label}" with value ` : '';
+    throw new WooksError(400, `${prefix}${JSON.stringify(value)} is not a ${targetType} type`);
+}
+
+const DEFAULT_ERROR_LIMIT = 10;
+function firstString(errors) {
+    const keys = Object.keys(errors);
+    for (const key of keys) {
+        if (typeof errors[key] === 'string')
+            return errors[key];
+        return firstString(errors[key]);
+    }
+    return '';
+}
+const validatePipe = (opts) => {
+    const pipe = (_value, meta) => __awaiter(void 0, void 0, void 0, function* () {
+        const { restoreCtx } = useHttpContext();
+        const valido = getMoostValido();
+        const result = yield valido.validateParam(_value, meta, undefined, undefined, undefined, undefined, 0, 0, (opts === null || opts === void 0 ? void 0 : opts.errorLimit) || DEFAULT_ERROR_LIMIT, restoreCtx);
+        if (result !== true) {
+            throw new WooksError(400, {
+                statusCode: 400,
+                message: typeof result === 'string' ? result : firstString(result),
+                error: 'Validation Error',
+                details: result,
+            });
+        }
+        return _value;
+    });
+    pipe.priority = exports.TPipePriority.VALIDATE;
+    return pipe;
+};
+
+exports.Circular = Circular;
+exports.Const = Const;
+exports.Controller = Controller;
+exports.Dto = Dto;
+exports.Id = Id;
+exports.ImportController = ImportController;
+exports.Inject = Inject;
+exports.Injectable = Injectable;
+exports.Intercept = Intercept;
+exports.InterceptorHandler = InterceptorHandler;
+exports.IsArray = IsArray;
+exports.IsBoolean = IsBoolean;
+exports.IsNumber = IsNumber;
+exports.IsString = IsString;
+exports.IsTypeOf = IsTypeOf;
+exports.Label = Label;
+exports.Moost = Moost;
+exports.Optional = Optional;
+exports.Param = Param;
+exports.Params = Params;
+exports.Provide = Provide;
+exports.Required = Required;
+exports.Resolve = Resolve;
+exports.Validate = Validate;
+exports.genericTypesCastPipe = genericTypesCastPipe;
+exports.getMoostMate = getMoostMate;
+exports.resolvePipe = resolvePipe;
+exports.useControllerMeta = useControllerMeta;
+exports.validatePipe = validatePipe;