@moostjs/event-cli 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -1,2285 +1,8 @@
 'use strict';
 
+var eventCli = require('@wooksjs/event-cli');
 var crypto = require('crypto');
-require('url');
-require('stream');
-require('http');
-
-/******************************************************************************
-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$1(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 banner$4 = () => `[${"@wooksjs/event-core"}][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
-
-/* istanbul ignore file */
-function logError$2(error) {
-    console.error('' + '' + banner$4() + error + '');
-}
-
-function panic$1(error) {
-    logError$2(error);
-    return new Error(error);
-}
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-function attachHook(target, opts, name) {
-    Object.defineProperty(target, name || 'value', {
-        get: opts.get,
-        set: opts.set,
-    });
-    return target;
-}
-
-let currentContext = null;
-/**
- * Create a new event context
- *
- * @param data
- * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
- */
-function createEventContext(data) {
-    const newContext = Object.assign({}, data);
-    currentContext = newContext;
-    return _getCtxHelpers(newContext);
-}
-/**
- * Use existing event context
- *
- * !Must be called syncronously while context is reachable
- *
- * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
- */
-function useEventContext(expectedTypes) {
-    var _a;
-    if (!currentContext) {
-        throw panic$1('Event context does not exist. Use event context synchronously within the runtime of the event.');
-    }
-    const cc = currentContext;
-    if (expectedTypes || typeof expectedTypes === 'string') {
-        const type = (_a = cc.event) === null || _a === void 0 ? void 0 : _a.type;
-        const types = typeof expectedTypes === 'string' ? [expectedTypes] : expectedTypes;
-        if (!types.includes(type))
-            panic$1(`Event context type mismatch: expected ${types.map(t => `"${t}"`).join(', ')}, received "${type}"`);
-    }
-    return _getCtxHelpers(cc);
-}
-function _getCtxHelpers(cc) {
-    /**
-     * Hook to an event store property
-     *
-     * @param key store property key
-     * @returns a hook { value: <prop value>, hook: (key2: keyof <prop value>) => { value: <nested prop value> }, ... }
-     */
-    function store(key) {
-        const obj = {
-            value: null,
-            hook,
-            init,
-            set: setNested,
-            get: getNested,
-            has: hasNested,
-            del: delNested,
-            entries,
-            clear,
-        };
-        attachHook(obj, {
-            set: v => set(key, v),
-            get: () => get(key),
-        });
-        function init(key2, getter) {
-            if (hasNested(key2))
-                return getNested(key2);
-            return setNested(key2, getter());
-        }
-        function hook(key2) {
-            const obj = {
-                value: null,
-                isDefined: null,
-            };
-            attachHook(obj, {
-                set: v => setNested(key2, v),
-                get: () => getNested(key2),
-            });
-            attachHook(obj, {
-                get: () => hasNested(key2),
-            }, 'isDefined');
-            return obj;
-        }
-        function setNested(key2, v) {
-            if (typeof obj.value === 'undefined') {
-                obj.value = {};
-            }
-            obj.value[key2] = v;
-            return v;
-        }
-        function delNested(key2) {
-            setNested(key2, undefined);
-        }
-        function getNested(key2) { return (obj.value || {})[key2]; }
-        function hasNested(key2) { return typeof (obj.value || {})[key2] !== 'undefined'; }
-        function entries() { return Object.entries((obj.value || {})); }
-        function clear() { obj.value = {}; }
-        return obj;
-    }
-    /**
-     * Get event context object
-     *
-     * @returns whole context object
-     */
-    function getCtx() { return cc; }
-    /**
-     * Get value of event store property
-     *
-     * @param key property name
-     * @returns value of property by name
-     */
-    function get(key) { return getCtx()[key]; }
-    /**
-     * Set value of event store property
-     *
-     * @param key property name
-     * @param v property value
-     */
-    function set(key, v) {
-        (getCtx())[key] = v;
-    }
-    return {
-        getCtx,
-        restoreCtx: () => currentContext = cc,
-        clearCtx: () => cc === currentContext ? currentContext = null : null,
-        store,
-        getStore: get,
-        setStore: set,
-    };
-}
-
-function useEventId() {
-    const { store } = useEventContext();
-    const { init } = store('event');
-    const getId = () => init('id', () => crypto.randomUUID());
-    return { getId };
-}
-
-class ProstoCache {
-    constructor(options) {
-        this.data = {};
-        this.limits = [];
-        this.expireOrder = [];
-        this.expireSeries = {};
-        this.options = {
-            limit: 1000,
-            ...options,
-        };
-    }
-    set(key, value) {
-        var _a, _b, _c;
-        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.limit) === 0)
-            return;
-        const expires = ((_b = this.options) === null || _b === void 0 ? void 0 : _b.ttl) ? Math.round(new Date().getTime() / 1) + ((_c = this.options) === null || _c === void 0 ? void 0 : _c.ttl) : null;
-        if (expires) {
-            this.del(key);
-        }
-        this.data[key] = {
-            value: value,
-            expires,
-        };
-        if (expires) {
-            this.pushExpires(key, expires);
-        }
-        this.pushLimit(key);
-    }
-    get(key) {
-        var _a;
-        return (_a = this.data[key]) === null || _a === void 0 ? void 0 : _a.value;
-    }
-    del(key) {
-        const entry = this.data[key];
-        if (entry) {
-            delete this.data[key];
-            if (entry.expires) {
-                let es = this.expireSeries[entry.expires];
-                if (es) {
-                    es = this.expireSeries[entry.expires] = es.filter(k => k !== key);
-                }
-                if (!es || !es.length) {
-                    delete this.expireSeries[entry.expires];
-                    const { found, index } = this.searchExpireOrder(entry.expires);
-                    if (found) {
-                        this.expireOrder.splice(index, 1);
-                        if (index === 0) {
-                            console.log('calling prepareTimeout');
-                            this.prepareTimeout();
-                        }
-                    }
-                }
-            }
-        }
-    }
-    reset() {
-        this.data = {};
-        if (this.nextTimeout) {
-            clearTimeout(this.nextTimeout);
-        }
-        this.expireOrder = [];
-        this.expireSeries = {};
-        this.limits = [];
-    }
-    searchExpireOrder(time) {
-        return binarySearch(this.expireOrder, time);
-    }
-    pushLimit(key) {
-        var _a;
-        const limit = (_a = this.options) === null || _a === void 0 ? void 0 : _a.limit;
-        if (limit) {
-            const newObj = [key, ...(this.limits.filter(item => item !== key && this.data[item]))];
-            const tail = newObj.slice(limit);
-            this.limits = newObj.slice(0, limit);
-            if (tail.length) {
-                tail.forEach(tailItem => {
-                    this.del(tailItem);
-                });
-            }
-        }
-    }
-    prepareTimeout() {
-        if (this.nextTimeout) {
-            clearTimeout(this.nextTimeout);
-        }
-        const time = this.expireOrder[0];
-        const del = (time) => {
-            for (const key of (this.expireSeries[time] || [])) {
-                delete this.data[key];
-            }
-            delete this.expireSeries[time];
-            this.expireOrder = this.expireOrder.slice(1);
-            this.prepareTimeout();
-        };
-        if (time) {
-            const delta = time - Math.round(new Date().getTime() / 1);
-            if (delta > 0) {
-                this.nextTimeout = setTimeout(() => {
-                    del(time);
-                }, delta);
-            }
-            else {
-                del(time);
-            }
-        }
-    }
-    pushExpires(key, time) {
-        const { found, index } = this.searchExpireOrder(time);
-        if (!found) {
-            this.expireOrder.splice(index, 0, time);
-        }
-        const e = this.expireSeries[time] = this.expireSeries[time] || [];
-        e.push(key);
-        if (!found && index === 0) {
-            this.prepareTimeout();
-        }
-    }
-}
-function binarySearch(a, n) {
-    let start = 0;
-    let end = a.length - 1;
-    let mid = 0;
-    while (start <= end) {
-        mid = Math.floor((start + end) / 2);
-        if (a[mid] === n) {
-            return {
-                found: true,
-                index: mid,
-            };
-        }
-        if (n < a[mid]) {
-            end = mid - 1;
-            mid--;
-        }
-        else {
-            start = mid + 1;
-            mid++;
-        }
-    }
-    return {
-        found: false,
-        index: mid,
-    };
-}
-
-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$1(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$1(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$3 = '' + '[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$3 + '', 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$3 + '', 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');
-        }
-    }
-}
-
-function parsePath(expr) {
-    return parser.parse(expr).extractCustomDataTree();
-}
-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);
-const parser = 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 safeDecode(f, v) {
-    try {
-        return f(v);
-    }
-    catch (e) {
-        return v;
-    }
-}
-function safeDecodeURIComponent(uri) {
-    if (uri.indexOf('%') < 0)
-        return uri;
-    return safeDecode(decodeURIComponent, uri);
-}
-function safeDecodeURI(uri) {
-    if (uri.indexOf('%') < 0)
-        return uri;
-    return safeDecode(decodeURI, uri);
-}
-
-function countOfSlashes(s) {
-    let last = 0;
-    let count = 0;
-    let index = s.indexOf('/');
-    last = index + 1;
-    while (index >= 0) {
-        count++;
-        index = s.indexOf('/', last);
-        last = index + 1;
-    }
-    return count;
-}
-
-class CodeString {
-    constructor() {
-        this.code = '';
-    }
-    append(s, newLine = false) {
-        this.code += ['', s].flat().join(newLine ? '\n' : '');
-    }
-    prepend(s, newLine = false) {
-        this.code = [s, ''].flat().join(newLine ? '\n' : '') + this.code;
-    }
-    generateFunction(...args) {
-        return new Function(args.join(','), this.code);
-    }
-    toString() {
-        return this.code;
-    }
-}
-
-function escapeRegex(s) {
-    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-}
-
-function generateFullMatchRegex(segments, nonCapturing = false) {
-    let regex = '';
-    segments.forEach(segment => {
-        switch (segment.type) {
-            case EPathSegmentType.STATIC:
-                regex += escapeRegex(segment.value);
-                break;
-            case EPathSegmentType.VARIABLE:
-            case EPathSegmentType.WILDCARD:
-                regex += nonCapturing ? segment.regex.replace(/^\(/, '(?:') : segment.regex;
-        }
-    });
-    return regex;
-}
-function generateFullMatchFunc(segments, ignoreCase = false) {
-    const str = new CodeString();
-    const regex = generateFullMatchRegex(segments);
-    let index = 0;
-    const obj = {};
-    segments.forEach(segment => {
-        switch (segment.type) {
-            case EPathSegmentType.VARIABLE:
-            case EPathSegmentType.WILDCARD:
-                index++;
-                obj[segment.value] = obj[segment.value] || [];
-                obj[segment.value].push(index);
-        }
-    });
-    Object.keys(obj).forEach(key => {
-        str.append(obj[key].length > 1
-            ? `\tparams['${key}'] = [${obj[key].map(i => `utils.safeDecodeURIComponent(a[${i}])`).join(', ')}]`
-            : `\tparams['${key}'] = utils.safeDecodeURIComponent(a[${obj[key][0]}])`, true);
-    });
-    str.prepend([`const a = path.match(/^${regex}$/${ignoreCase ? 'i' : ''})`, 'if (a) {'], true);
-    str.append(['}', 'return a'], true);
-    return str.generateFunction('path', 'params', 'utils');
-}
-function generatePathBuilder(segments) {
-    const str = new CodeString();
-    const obj = {};
-    const index = {};
-    segments.forEach(segment => {
-        switch (segment.type) {
-            case EPathSegmentType.VARIABLE:
-            case EPathSegmentType.WILDCARD:
-                obj[segment.value] = obj[segment.value] || 0;
-                obj[segment.value]++;
-                index[segment.value] = 0;
-        }
-    });
-    str.append('return `');
-    segments.forEach(segment => {
-        switch (segment.type) {
-            case EPathSegmentType.STATIC:
-                str.append(segment.value.replace(/`/g, '\\`'));
-                break;
-            case EPathSegmentType.VARIABLE:
-            case EPathSegmentType.WILDCARD:
-                if (obj[segment.value] > 1) {
-                    str.append('${ params[\'' + segment.value + `\'][${index[segment.value]}] }`);
-                    index[segment.value]++;
-                }
-                else {
-                    str.append('${ params[\'' + segment.value + '\'] }');
-                }
-        }
-    });
-    str.append('`');
-    return str.generateFunction('params');
-}
-
-const banner$2 = () => `[prostojs/router][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
-
-const methods = ['GET', 'PUT', 'POST', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
-const matcherFuncUtils = {
-    safeDecodeURIComponent,
-};
-class ProstoRouter {
-    constructor(_options) {
-        this.root = {};
-        this.routes = [];
-        this.routesRegistry = {};
-        this._options = {
-            ..._options,
-        };
-        if (!this._options.silent) {
-            consoleInfo('The Router Initialized');
-        }
-        const cacheOpts = {
-            limit: (_options === null || _options === void 0 ? void 0 : _options.cacheLimit) || 0,
-        };
-        if (_options === null || _options === void 0 ? void 0 : _options.cacheLimit) {
-            this.cache = {
-                GET: new ProstoCache(cacheOpts),
-                PUT: new ProstoCache(cacheOpts),
-                POST: new ProstoCache(cacheOpts),
-                PATCH: new ProstoCache(cacheOpts),
-                DELETE: new ProstoCache(cacheOpts),
-                HEAD: new ProstoCache(cacheOpts),
-                OPTIONS: new ProstoCache(cacheOpts),
-            };
-        }
-    }
-    refreshCache(method) {
-        if (this._options.cacheLimit && this.cache) {
-            if (method === '*') {
-                this.cache.GET.reset();
-                this.cache.PUT.reset();
-                this.cache.POST.reset();
-                this.cache.PATCH.reset();
-                this.cache.DELETE.reset();
-                this.cache.HEAD.reset();
-                this.cache.OPTIONS.reset();
-            }
-            else if (this.cache && this.cache[method]) {
-                this.cache[method].reset();
-            }
-        }
-    }
-    registerRoute(method, path, options, handler) {
-        this.refreshCache(method);
-        const opts = this.mergeOptions(options);
-        const normalPath = ('/' + path)
-            .replace(/^\/\//, '/')
-            .replace(/\/$/, '')
-            .replace(/%/g, '%25');
-        const { root } = this;
-        const segments = parsePath(normalPath);
-        if (!root[method]) {
-            root[method] = {
-                statics: {},
-                parametrics: {
-                    byParts: [],
-                },
-                wildcards: [],
-            };
-        }
-        const rootMethod = root[method];
-        const generalized = method + ':' + segments.map(s => {
-            switch (s.type) {
-                case EPathSegmentType.STATIC: return s.value;
-                case EPathSegmentType.VARIABLE: return '<VAR' + (s.regex === '([^-\\/]*)' ? '' : s.regex) + '>';
-                case EPathSegmentType.WILDCARD: return s.value;
-            }
-        }).join('');
-        let route = this.routesRegistry[generalized];
-        if (route) {
-            if (this._options.disableDuplicatePath) {
-                const error = `Attempt to register duplicated path: "${path}". Duplicate paths are disabled.\nYou can enable duplicated paths removing 'disableDuplicatePath' option.`;
-                consoleError(error);
-                throw new Error(error);
-            }
-            if (route.handlers.includes(handler)) {
-                consoleError('Duplicate route with same handler ignored ' + generalized);
-            }
-            else {
-                consoleWarn('Duplicate route registered ' + generalized);
-                route.handlers.push(handler);
-            }
-        }
-        else {
-            const isStatic = segments.length === 1 && segments[0].type === EPathSegmentType.STATIC || segments.length === 0;
-            const isParametric = !!segments.find(p => p.type === EPathSegmentType.VARIABLE);
-            const isWildcard = !!segments.find(p => p.type === EPathSegmentType.WILDCARD);
-            const lengths = segments.map(s => s.type === EPathSegmentType.STATIC ? s.value.length : 0);
-            const normalPathCase = segments[0] ? (this._options.ignoreCase ? segments[0].value.toLowerCase() : segments[0].value) : '/';
-            this.routesRegistry[generalized] = route = {
-                method,
-                options: opts,
-                path: normalPath,
-                handlers: [handler],
-                isStatic,
-                isParametric,
-                isWildcard,
-                segments,
-                lengths,
-                minLength: lengths.reduce((a, b) => a + b, 0),
-                firstLength: lengths[0],
-                firstStatic: normalPathCase.slice(0, lengths[0]),
-                generalized,
-                fullMatch: generateFullMatchFunc(segments, this._options.ignoreCase),
-                pathBuilder: generatePathBuilder(segments),
-            };
-            this.routes.push(route);
-            if (route.isStatic) {
-                rootMethod.statics[normalPathCase] = route;
-            }
-            else {
-                if (route.isParametric && !route.isWildcard) {
-                    const countOfParts = route.segments
-                        .filter(s => s.type === EPathSegmentType.STATIC)
-                        .map(s => countOfSlashes(s.value)).reduce((a, b) => a + b, 1);
-                    const byParts = rootMethod.parametrics.byParts[countOfParts] = rootMethod.parametrics.byParts[countOfParts] || [];
-                    byParts.push(route);
-                    rootMethod.parametrics.byParts[countOfParts] = byParts.sort(routeSorter);
-                }
-                else if (route.isWildcard) {
-                    rootMethod.wildcards.push(route);
-                    rootMethod.wildcards = rootMethod.wildcards.sort(routeSorter);
-                }
-            }
-        }
-        return route.pathBuilder;
-    }
-    mergeOptions(options) {
-        return {
-            ...options,
-        };
-    }
-    sanitizePath(path) {
-        const end = path.indexOf('?');
-        let slicedPath = end >= 0 ? path.slice(0, end) : path;
-        if (this._options.ignoreTrailingSlash && slicedPath[slicedPath.length - 1] === '/') {
-            slicedPath = slicedPath.slice(0, slicedPath.length - 1);
-        }
-        const normalPath = safeDecodeURI(slicedPath
-            .replace(/%25/g, '%2525'));
-        return {
-            normalPath,
-            normalPathWithCase: this._options.ignoreCase ? normalPath.toLowerCase() : normalPath,
-        };
-    }
-    lookup(method, path) {
-        if (this._options.cacheLimit && this.cache && this.cache[method]) {
-            const cached = this.cache[method].get(path);
-            if (cached)
-                return cached;
-        }
-        const { normalPath, normalPathWithCase } = this.sanitizePath(path);
-        const rootMethod = this.root[method];
-        const lookupResult = {
-            route: null,
-            ctx: { params: {} },
-        };
-        const cache = (result) => {
-            if (this._options.cacheLimit && this.cache && this.cache[method]) {
-                this.cache[method].set(path, result);
-            }
-            return result;
-        };
-        if (rootMethod) {
-            lookupResult.route = rootMethod.statics[normalPathWithCase];
-            if (lookupResult.route)
-                return cache(lookupResult);
-            const pathSegmentsCount = countOfSlashes(normalPath) + 1;
-            const pathLength = normalPath.length;
-            const { parametrics } = rootMethod;
-            const bySegments = parametrics.byParts[pathSegmentsCount];
-            if (bySegments) {
-                for (let i = 0; i < bySegments.length; i++) {
-                    lookupResult.route = bySegments[i];
-                    if (pathLength >= lookupResult.route.minLength) {
-                        if (normalPathWithCase.startsWith(lookupResult.route.firstStatic)
-                            && lookupResult.route.fullMatch(normalPath, lookupResult.ctx.params, matcherFuncUtils)) {
-                            return cache(lookupResult);
-                        }
-                    }
-                }
-            }
-            const { wildcards } = rootMethod;
-            for (let i = 0; i < wildcards.length; i++) {
-                lookupResult.route = wildcards[i];
-                if (pathLength >= lookupResult.route.minLength) {
-                    if (normalPathWithCase.startsWith(lookupResult.route.firstStatic)
-                        && lookupResult.route.fullMatch(normalPath, lookupResult.ctx.params, matcherFuncUtils)) {
-                        return cache(lookupResult);
-                    }
-                }
-            }
-        }
-    }
-    find(method, path) {
-        return this.lookup(method, path);
-    }
-    on(method, path, options, handler) {
-        const { opts, func } = extractOptionsAndHandler(options, handler);
-        if (method === '*') {
-            return methods.map(m => this.registerRoute(m, path, opts, func))[0];
-        }
-        return this.registerRoute(method, path, opts, func);
-    }
-    all(path, options, handler) {
-        const { opts, func } = extractOptionsAndHandler(options, handler);
-        return this.on('*', path, opts, func);
-    }
-    get(path, options, handler) {
-        const { opts, func } = extractOptionsAndHandler(options, handler);
-        return this.on('GET', path, opts, func);
-    }
-    put(path, options, handler) {
-        const { opts, func } = extractOptionsAndHandler(options, handler);
-        return this.on('PUT', path, opts, func);
-    }
-    post(path, options, handler) {
-        const { opts, func } = extractOptionsAndHandler(options, handler);
-        return this.on('POST', path, opts, func);
-    }
-    patch(path, options, handler) {
-        const { opts, func } = extractOptionsAndHandler(options, handler);
-        return this.on('PATCH', path, opts, func);
-    }
-    delete(path, options, handler) {
-        const { opts, func } = extractOptionsAndHandler(options, handler);
-        return this.on('DELETE', path, opts, func);
-    }
-    options(path, options, handler) {
-        const { opts, func } = extractOptionsAndHandler(options, handler);
-        return this.on('OPTIONS', path, opts, func);
-    }
-    head(path, options, handler) {
-        const { opts, func } = extractOptionsAndHandler(options, handler);
-        return this.on('HEAD', path, opts, func);
-    }
-    getRoutes() {
-        return this.routes;
-    }
-    toTree() {
-        const rootStyle = (v) => '' + v + '';
-        const paramStyle = (v) => '' + '' + ':' + v + '' + '';
-        const regexStyle = (v) => '' + '' + v + '' + '';
-        const handlerStyle = (v) => '' + '' + '→ ' + '' + '' + v;
-        const methodStyle = (v) => '' + '' + '• (' + v + ') ' + '';
-        const data = {
-            label: '⁕ Router',
-            stylist: rootStyle,
-            methods: [],
-            children: [],
-        };
-        function toChild(d, label, stylist) {
-            let found = d.children.find(c => c.label === label);
-            if (!found) {
-                found = {
-                    label,
-                    stylist,
-                    methods: [],
-                    children: [],
-                };
-                d.children.push(found);
-            }
-            return found;
-        }
-        this.routes.sort((a, b) => a.path > b.path ? 1 : -1).forEach(route => {
-            let cur = data;
-            let last = '';
-            route.segments.forEach(s => {
-                switch (s.type) {
-                    case EPathSegmentType.STATIC:
-                        const parts = s.value.split('/');
-                        last += parts.shift();
-                        for (let i = 0; i < parts.length; i++) {
-                            if (last) {
-                                cur = toChild(cur, last);
-                            }
-                            last = '/' + parts[i];
-                        }
-                        break;
-                    case EPathSegmentType.VARIABLE:
-                    case EPathSegmentType.WILDCARD:
-                        last += `${paramStyle(s.value)}${regexStyle(s.regex)}`;
-                }
-            });
-            if (last) {
-                cur = toChild(cur, last, handlerStyle);
-                cur.methods.push(route.method);
-            }
-        });
-        new ProstoTree({
-            renderLabel: (node, behind) => {
-                const styledLabel = node.stylist ? node.stylist(node.label) : node.label;
-                if (node.methods.length) {
-                    return styledLabel + '\n' + behind + node.methods.map(m => methodStyle(m)).join('\n' + behind);
-                }
-                return styledLabel;
-            },
-        }).print(data);
-    }
-}
-function extractOptionsAndHandler(options, handler) {
-    let opts = {};
-    let func = handler;
-    if (typeof options === 'function') {
-        func = options;
-    }
-    else {
-        opts = options;
-    }
-    return { opts, func };
-}
-function routeSorter(a, b) {
-    if (a.isWildcard !== b.isWildcard) {
-        return a.isWildcard ? 1 : -1;
-    }
-    const len = b.minLength - a.minLength;
-    if (len)
-        return len;
-    for (let i = 0; i < a.lengths.length; i++) {
-        const len = b.lengths[i] - a.lengths[i];
-        if (len)
-            return len;
-    }
-    return 0;
-}
-function consoleError(v) {
-    console.info('' + banner$2() + v + '');
-}
-function consoleWarn(v) {
-    console.info('' + banner$2() + v + '');
-}
-function consoleInfo(v) {
-    console.info('' + '' + banner$2() + v + '' + '');
-}
-
-class Wooks {
-    constructor() {
-        this.router = new ProstoRouter({
-            silent: true,
-        });
-    }
-    getRouter() {
-        return this.router;
-    }
-    lookup(method, path) {
-        var _a, _b;
-        const found = this.getRouter().lookup(method, path || '');
-        useEventContext().store('routeParams').value = ((_a = found === null || found === void 0 ? void 0 : found.ctx) === null || _a === void 0 ? void 0 : _a.params) || {};
-        return ((_b = found === null || found === void 0 ? void 0 : found.route) === null || _b === void 0 ? void 0 : _b.handlers) || null;
-    }
-    on(method, path, handler) {
-        return this.router.on(method, path, handler);
-    }
-}
-let gWooks;
-function getGlobalWooks() {
-    if (!gWooks) {
-        gWooks = new Wooks();
-    }
-    return gWooks;
-}
-class WooksAdapterBase {
-    constructor(wooks) {
-        if (wooks && wooks instanceof WooksAdapterBase) {
-            this.wooks = wooks.getWooks();
-        }
-        else if (wooks && wooks instanceof Wooks) {
-            this.wooks = wooks;
-        }
-        else {
-            this.wooks = getGlobalWooks();
-        }
-    }
-    getWooks() {
-        return this.wooks;
-    }
-    on(method, path, handler) {
-        return this.wooks.on(method, path, handler);
-    }
-}
-
-var minimist = function (args, opts) {
-    if (!opts) opts = {};
-    
-    var flags = { bools : {}, strings : {}, unknownFn: null };
-
-    if (typeof opts['unknown'] === 'function') {
-        flags.unknownFn = opts['unknown'];
-    }
-
-    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
-      flags.allBools = true;
-    } else {
-      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
-          flags.bools[key] = true;
-      });
-    }
-    
-    var aliases = {};
-    Object.keys(opts.alias || {}).forEach(function (key) {
-        aliases[key] = [].concat(opts.alias[key]);
-        aliases[key].forEach(function (x) {
-            aliases[x] = [key].concat(aliases[key].filter(function (y) {
-                return x !== y;
-            }));
-        });
-    });
-
-    [].concat(opts.string).filter(Boolean).forEach(function (key) {
-        flags.strings[key] = true;
-        if (aliases[key]) {
-            flags.strings[aliases[key]] = true;
-        }
-     });
-
-    var defaults = opts['default'] || {};
-    
-    var argv = { _ : [] };
-    Object.keys(flags.bools).forEach(function (key) {
-        setArg(key, defaults[key] === undefined ? false : defaults[key]);
-    });
-    
-    var notFlags = [];
-
-    if (args.indexOf('--') !== -1) {
-        notFlags = args.slice(args.indexOf('--')+1);
-        args = args.slice(0, args.indexOf('--'));
-    }
-
-    function argDefined(key, arg) {
-        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
-            flags.strings[key] || flags.bools[key] || aliases[key];
-    }
-
-    function setArg (key, val, arg) {
-        if (arg && flags.unknownFn && !argDefined(key, arg)) {
-            if (flags.unknownFn(arg) === false) return;
-        }
-
-        var value = !flags.strings[key] && isNumber(val)
-            ? Number(val) : val
-        ;
-        setKey(argv, key.split('.'), value);
-        
-        (aliases[key] || []).forEach(function (x) {
-            setKey(argv, x.split('.'), value);
-        });
-    }
-
-    function setKey (obj, keys, value) {
-        var o = obj;
-        for (var i = 0; i < keys.length-1; i++) {
-            var key = keys[i];
-            if (isConstructorOrProto(o, key)) return;
-            if (o[key] === undefined) o[key] = {};
-            if (o[key] === Object.prototype || o[key] === Number.prototype
-                || o[key] === String.prototype) o[key] = {};
-            if (o[key] === Array.prototype) o[key] = [];
-            o = o[key];
-        }
-
-        var key = keys[keys.length - 1];
-        if (isConstructorOrProto(o, key)) return;
-        if (o === Object.prototype || o === Number.prototype
-            || o === String.prototype) o = {};
-        if (o === Array.prototype) o = [];
-        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
-            o[key] = value;
-        }
-        else if (Array.isArray(o[key])) {
-            o[key].push(value);
-        }
-        else {
-            o[key] = [ o[key], value ];
-        }
-    }
-    
-    function aliasIsBoolean(key) {
-      return aliases[key].some(function (x) {
-          return flags.bools[x];
-      });
-    }
-
-    for (var i = 0; i < args.length; i++) {
-        var arg = args[i];
-        
-        if (/^--.+=/.test(arg)) {
-            // Using [\s\S] instead of . because js doesn't support the
-            // 'dotall' regex modifier. See:
-            // http://stackoverflow.com/a/1068308/13216
-            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
-            var key = m[1];
-            var value = m[2];
-            if (flags.bools[key]) {
-                value = value !== 'false';
-            }
-            setArg(key, value, arg);
-        }
-        else if (/^--no-.+/.test(arg)) {
-            var key = arg.match(/^--no-(.+)/)[1];
-            setArg(key, false, arg);
-        }
-        else if (/^--.+/.test(arg)) {
-            var key = arg.match(/^--(.+)/)[1];
-            var next = args[i + 1];
-            if (next !== undefined && !/^-/.test(next)
-            && !flags.bools[key]
-            && !flags.allBools
-            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
-                setArg(key, next, arg);
-                i++;
-            }
-            else if (/^(true|false)$/.test(next)) {
-                setArg(key, next === 'true', arg);
-                i++;
-            }
-            else {
-                setArg(key, flags.strings[key] ? '' : true, arg);
-            }
-        }
-        else if (/^-[^-]+/.test(arg)) {
-            var letters = arg.slice(1,-1).split('');
-            
-            var broken = false;
-            for (var j = 0; j < letters.length; j++) {
-                var next = arg.slice(j+2);
-                
-                if (next === '-') {
-                    setArg(letters[j], next, arg);
-                    continue;
-                }
-                
-                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
-                    setArg(letters[j], next.split('=')[1], arg);
-                    broken = true;
-                    break;
-                }
-                
-                if (/[A-Za-z]/.test(letters[j])
-                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
-                    setArg(letters[j], next, arg);
-                    broken = true;
-                    break;
-                }
-                
-                if (letters[j+1] && letters[j+1].match(/\W/)) {
-                    setArg(letters[j], arg.slice(j+2), arg);
-                    broken = true;
-                    break;
-                }
-                else {
-                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
-                }
-            }
-            
-            var key = arg.slice(-1)[0];
-            if (!broken && key !== '-') {
-                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
-                && !flags.bools[key]
-                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
-                    setArg(key, args[i+1], arg);
-                    i++;
-                }
-                else if (args[i+1] && /^(true|false)$/.test(args[i+1])) {
-                    setArg(key, args[i+1] === 'true', arg);
-                    i++;
-                }
-                else {
-                    setArg(key, flags.strings[key] ? '' : true, arg);
-                }
-            }
-        }
-        else {
-            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
-                argv._.push(
-                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
-                );
-            }
-            if (opts.stopEarly) {
-                argv._.push.apply(argv._, args.slice(i + 1));
-                break;
-            }
-        }
-    }
-    
-    Object.keys(defaults).forEach(function (key) {
-        if (!hasKey(argv, key.split('.'))) {
-            setKey(argv, key.split('.'), defaults[key]);
-            
-            (aliases[key] || []).forEach(function (x) {
-                setKey(argv, x.split('.'), defaults[key]);
-            });
-        }
-    });
-    
-    if (opts['--']) {
-        argv['--'] = new Array();
-        notFlags.forEach(function(key) {
-            argv['--'].push(key);
-        });
-    }
-    else {
-        notFlags.forEach(function(key) {
-            argv._.push(key);
-        });
-    }
-
-    return argv;
-};
-
-function hasKey (obj, keys) {
-    var o = obj;
-    keys.slice(0,-1).forEach(function (key) {
-        o = (o[key] || {});
-    });
-
-    var key = keys[keys.length - 1];
-    return key in o;
-}
-
-function isNumber (x) {
-    if (typeof x === 'number') return true;
-    if (/^0x[0-9a-f]+$/i.test(x)) return true;
-    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
-}
-
-
-function isConstructorOrProto (obj, key) {
-    return key === 'constructor' && typeof obj[key] === 'function' || key === '__proto__';
-}
-
-function createCliContext(data) {
-    return createEventContext({
-        event: Object.assign(Object.assign({}, data), { type: 'CLI' }),
-    });
-}
-function useCliContext() {
-    return useEventContext('CLI');
-}
+var moost = require('moost');
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -2306,79 +29,47 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const banner$1 = () => `[${"@wooksjs/event-cli"}][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
+const banner = () => `[${"@wooksjs/event-core"}][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
 
 /* istanbul ignore file */
-function logError$1(error) {
-    console.error('' + '' + banner$1() + error + '');
+function logError(error) {
+    console.error('' + '' + banner() + error + '');
 }
-class WooksCli extends WooksAdapterBase {
-    constructor(opts, wooks) {
-        super(wooks);
-        this.opts = opts;
-    }
-    cli(path, handler) {
-        return this.on('CLI', path, handler);
-    }
-    run(_argv) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const argv = process.argv.slice(2) || _argv;
-            const firstFlagIndex = argv.findIndex(a => a.startsWith('-')) + 1;
-            const path = '/' + (firstFlagIndex ? argv.slice(0, firstFlagIndex - 1) : argv).map(v => encodeURIComponent(v)).join('/');
-            const { restoreCtx, clearCtx } = createCliContext({ argv });
-            const handlers = this.wooks.lookup('CLI', path);
-            if (handlers) {
-                try {
-                    for (const handler of handlers) {
-                        restoreCtx();
-                        const response = yield handler();
-                        if (typeof response === 'string') {
-                            console.log(response);
-                        }
-                        else if (Array.isArray(response)) {
-                            response.forEach(r => console.log(typeof r === 'string' ? r : JSON.stringify(r, null, '  ')));
-                        }
-                        else {
-                            console.log(JSON.stringify(response, null, '  '));
-                        }
-                    }
-                }
-                catch (e) {
-                    logError$1(e.message);
-                    process.exit(1);
-                }
-                clearCtx();
-            }
-            else {
-                logError$1('Unknown command parameters');
-                process.exit(1);
-            }
-        });
+
+function panic(error) {
+    logError(error);
+    return new Error(error);
+}
+/**
+ * Use existing event context
+ *
+ * !Must be called syncronously while context is reachable
+ *
+ * @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
+ */
+function useEventContext(expectedTypes) {
+    {
+        throw panic('Event context does not exist. Use event context synchronously within the runtime of the event.');
     }
 }
-function createCliApp(opts, wooks) {
-    return new WooksCli(opts, wooks);
-}
 
-function useFlags() {
-    const { store } = useCliContext();
-    const flags = store('flags');
-    if (!flags.value) {
-        flags.value = minimist(store('event').value.argv);
-    }
-    return flags.value;
+function useEventId() {
+    const { store } = useEventContext();
+    const { init } = store('event');
+    const getId = () => init('id', () => crypto.randomUUID());
+    return { getId };
 }
 
 class MoostCli {
     constructor(cliApp) {
-        if (cliApp && cliApp instanceof WooksCli) {
+        if (cliApp && cliApp instanceof eventCli.WooksCli) {
             this.cliApp = cliApp;
         }
         else if (cliApp) {
-            this.cliApp = createCliApp(cliApp);
+            this.cliApp = eventCli.createCliApp(cliApp);
         }
         else {
-            this.cliApp = createCliApp();
+            this.cliApp = eventCli.createCliApp();
         }
     }
     onInit() {
@@ -2392,8 +83,8 @@ class MoostCli {
             const path = typeof handler.path === 'string' ? handler.path : typeof opts.method === 'string' ? opts.method : '';
             const targetPath = `${opts.prefix || ''}/${path}`.replace(/\/\/+/g, '/');
             if (!fn) {
-                fn = () => __awaiter$1(this, void 0, void 0, function* () {
-                    const { restoreCtx } = useCliContext();
+                fn = () => __awaiter(this, void 0, void 0, function* () {
+                    const { restoreCtx } = eventCli.useCliContext();
                     const scopeId = useEventId().getId();
                     const unscope = opts.registerEventScope(scopeId);
                     const instance = yield opts.getInstance();
@@ -2438,339 +129,6 @@ class MoostCli {
     }
 }
 
-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,
-});
-
-function getConstructor(instance) {
-    return isConstructor(instance) ?
-        instance : instance.constructor ?
-        instance.constructor : Object.getPrototypeOf(instance).constructor;
-}
-function isConstructor(v) {
-    return typeof v === 'function' && Object.getOwnPropertyNames(v).includes('prototype') && !Object.getOwnPropertyNames(v).includes('caller') && !!v.name;
-}
-
-const banner = () => `[prostojs/mate][${new Date().toISOString().replace('T', ' ').replace(/\.\d{3}z$/i, '')}] `;
-
-function warn(text) {
-    console.log('' + banner() + text + '');
-}
-function logError(error) {
-    console.error('' + '' + banner() + error + '');
-}
-
-const classMetadata = {};
-const paramMetadata = {};
-const root = typeof global === 'object' ? global : typeof self === 'object' ? self : {};
-function getMetaObject(target, prop) {
-    const isParam = typeof prop !== 'undefined';
-    const metadata = isParam ? paramMetadata : classMetadata;
-    const targetKey = Symbol.for(getConstructor(target));
-    let meta = metadata[targetKey] = metadata[targetKey] || {};
-    if (isParam)
-        meta = (meta[prop] = meta[prop] || {});
-    return meta;
-}
-const _reflect = {
-    getOwnMetadata(key, target, prop) {
-        return getMetaObject(target, prop)[key];
-    },
-    defineMetadata(key, data, target, prop) {
-        const meta = getMetaObject(target, prop);
-        meta[key] = data;
-    },
-    metadata(key, data) {
-        return ((target, propKey) => {
-            Reflect$1.defineMetadata(key, data, target, propKey);
-        });
-    },
-};
-if (!root.Reflect) {
-    root.Reflect = _reflect;
-}
-else {
-    const funcs = [
-        'getOwnMetadata',
-        'defineMetadata',
-        'metadata',
-    ];
-    const target = root.Reflect;
-    let isOriginalReflectMetadata = true;
-    for (const func of funcs) {
-        if (typeof target[func] !== 'function') {
-            Object.defineProperty(target, func, { configurable: true, writable: true, value: _reflect[func] });
-            isOriginalReflectMetadata = false;
-        }
-    }
-    if (!isOriginalReflectMetadata) {
-        warn('A limited \'reflect-metadata\' implementation is used. In case of any issues include original \'reflect-metadata\' package and require it before any @prostojs/mate import.');
-    }
-}
-const Reflect$1 = _reflect;
-
-function panic(error) {
-    logError(error);
-    return new Error(error);
-}
-
-const Reflect = (global === null || global === void 0 ? void 0 : global.Reflect) || (self === null || self === void 0 ? void 0 : self.Reflect) || Reflect$1;
-class Mate {
-    constructor(workspace, options = {}) {
-        this.workspace = workspace;
-        this.options = options;
-    }
-    set(args, key, value, isArray) {
-        var _a;
-        const newArgs = args.level === 'CLASS' ? { target: args.target }
-            : args.level === 'PROPERTY' ? { target: args.target, propKey: args.propKey }
-                : args;
-        let meta = Reflect.getOwnMetadata(this.workspace, newArgs.target, newArgs.propKey) || {};
-        if (newArgs.propKey && this.options.readReturnType && !meta.returnType) {
-            meta.returnType = Reflect.getOwnMetadata('design:returntype', newArgs.target, newArgs.propKey);
-        }
-        if (newArgs.propKey && this.options.readType && !meta.type) {
-            meta.type = Reflect.getOwnMetadata('design:type', newArgs.target, newArgs.propKey);
-        }
-        const { index } = newArgs;
-        const cb = typeof key === 'function' ? key : undefined;
-        let data = meta;
-        if (!data.params) {
-            data.params = (_a = Reflect.getOwnMetadata('design:paramtypes', newArgs.target, newArgs.propKey)) === null || _a === void 0 ? void 0 : _a.map((f) => ({ type: f }));
-        }
-        if (typeof index === 'number') {
-            data.params = data.params || [];
-            data.params[index] = data.params[index] || {
-                type: undefined,
-            };
-            if (cb) {
-                data.params[index] = cb(data.params[index], args.propKey, typeof args.index === 'number' ? args.index : undefined);
-            }
-            else {
-                data = data.params[index];
-            }
-        }
-        if (typeof key !== 'function') {
-            if (isArray) {
-                const newArray = (data[key] || []);
-                if (!Array.isArray(newArray)) {
-                    panic('Mate.add (isArray=true) called for non-array metadata');
-                }
-                newArray.unshift(value);
-                data[key] = newArray;
-            }
-            else {
-                data[key] = value;
-            }
-        }
-        else if (cb && typeof index !== 'number') {
-            meta = cb(data, args.propKey, typeof args.index === 'number' ? args.index : undefined);
-        }
-        Reflect.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
-    }
-    read(target, propKey, index) {
-        const isConstr = isConstructor(target);
-        const constructor = isConstr ? target : getConstructor(target);
-        const proto = constructor.prototype;
-        let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === 'string' ? proto : constructor, propKey);
-        if (this.options.inherit) {
-            const inheritFn = typeof this.options.inherit === 'function' ? this.options.inherit : undefined;
-            let shouldInherit = this.options.inherit;
-            if (inheritFn) {
-                if (typeof propKey === 'string') {
-                    const classMeta = Reflect.getOwnMetadata(this.workspace, constructor);
-                    shouldInherit = inheritFn(classMeta, propKey, ownMeta);
-                }
-                else {
-                    shouldInherit = inheritFn(ownMeta);
-                }
-            }
-            if (shouldInherit) {
-                const parent = Object.getPrototypeOf(constructor);
-                if (typeof parent === 'function' && parent !== fnProto && parent !== constructor) {
-                    const inheritedMeta = this.read(parent, propKey);
-                    ownMeta = { ...inheritedMeta, ...ownMeta, params: ownMeta === null || ownMeta === void 0 ? void 0 : ownMeta.params };
-                }
-            }
-        }
-        return ownMeta;
-    }
-    apply(...decorators) {
-        return ((target, propKey, descriptor) => {
-            for (const d of decorators) {
-                d(target, propKey, descriptor);
-            }
-        });
-    }
-    decorate(key, value, isArray, level) {
-        return ((target, propKey, descriptor) => {
-            const args = {
-                target,
-                propKey,
-                descriptor: typeof descriptor === 'number' ? undefined : descriptor,
-                index: typeof descriptor === 'number' ? descriptor : undefined,
-                level,
-            };
-            this.set(args, key, value, isArray);
-        });
-    }
-    decorateClass(key, value, isArray) {
-        return this.decorate(key, value, isArray, 'CLASS');
-    }
-}
-const fnProto = Object.getPrototypeOf(Function);
-
-const METADATA_WORKSPACE = 'moost';
-const moostMate = new Mate(METADATA_WORKSPACE, {
-    readType: true,
-    readReturnType: true,
-});
-function getMoostMate() {
-    return moostMate;
-}
-
-var TPipePriority;
-(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";
-})(TPipePriority || (TPipePriority = {}));
-
-const resolvePipe = (_value, meta) => {
-    if (meta === null || meta === void 0 ? void 0 : meta.resolver) {
-        return meta.resolver();
-    }
-    return undefined;
-};
-resolvePipe.priority = TPipePriority.RESOLVE;
-
-[
-    {
-        handler: resolvePipe,
-        priority: TPipePriority.RESOLVE,
-    },
-];
-
-function Label(value) {
-    return getMoostMate().decorate('label', value);
-}
-
-/**
- * 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);
-    };
-}
-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);
-        }
-    }
-}
-
-getMoostMate().decorate((meta) => {
-    if (!meta.injectable)
-        meta.injectable = true;
-    return meta;
-});
-
-var TInterceptorPriority;
-(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";
-})(TInterceptorPriority || (TInterceptorPriority = {}));
-
 /**
  * Get Cli Flag
  * @decorator
@@ -2778,7 +136,7 @@ var TInterceptorPriority;
  * @paramType string
  */
 function Flag(name) {
-    return Resolve(() => useFlags()[name], name);
+    return moost.Resolve(() => eventCli.useFlags()[name], name);
 }
 /**
  * Get Cli Flags
@@ -2786,11 +144,11 @@ function Flag(name) {
  * @paramType object
  */
 function Flags() {
-    return Resolve(() => useFlags(), 'flags');
+    return moost.Resolve(() => eventCli.useFlags(), 'flags');
 }
 
 function Cli(path) {
-    return getMoostMate().decorate('handlers', { path, type: 'CLI' }, true);
+    return moost.getMoostMate().decorate('handlers', { path, type: 'CLI' }, true);
 }
 
 exports.Cli = Cli;