@moostjs/otel 0.4.21 → 0.4.23

package/dist/index.cjs

@@ -347,8 +347,8 @@ function isConstructor(v) {
     return typeof v === 'function' && Object.getOwnPropertyNames(v).includes('prototype') && !Object.getOwnPropertyNames(v).includes('caller') && !!v.name;
 }
 
-const classMetadata = new WeakMap();
-const paramMetadata = new WeakMap();
+let classMetadata = new WeakMap();
+let paramMetadata = new WeakMap();
 const root = typeof global === 'object' ? global : typeof self === 'object' ? self : {};
 function getMetaObject(target, prop) {
     const isParam = typeof prop !== 'undefined';
@@ -378,6 +378,10 @@ const _reflect = {
             Reflect$1.defineMetadata(key, data, target, propKey);
         });
     },
+    _cleanup: (() => {
+        classMetadata = new WeakMap();
+        paramMetadata = new WeakMap();
+    }),
 };
 if (!root.Reflect) {
     root.Reflect = _reflect;
@@ -397,31 +401,42 @@ else {
 }
 const Reflect$1 = _reflect;
 
-const Reflect = (global === null || global === void 0 ? void 0 : global.Reflect) || (self === null || self === void 0 ? void 0 : self.Reflect) || Reflect$1;
+const Reflect$2 = ((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;
         this.logger = options.logger || console;
     }
+    _cleanup() {
+        var _a;
+        (_a = Reflect$2._cleanup) === null || _a === void 0 ? void 0 : _a.call(Reflect$2);
+    }
     set(args, key, value, isArray) {
         var _a;
         let level = 'CLASS';
-        const newArgs = args.level === 'CLASS' ? { target: args.target }
-            : args.level === 'PROP' ? { target: args.target, propKey: args.propKey }
+        const newArgs = args.level === 'CLASS'
+            ? { target: args.target }
+            : args.level === 'PROP'
+                ? { 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 && args.descriptor) {
-            meta.returnType = Reflect.getOwnMetadata('design:returntype', newArgs.target, newArgs.propKey);
+        let meta = (Reflect$2.getOwnMetadata(this.workspace, newArgs.target, newArgs.propKey) || {});
+        if (newArgs.propKey &&
+            this.options.readReturnType &&
+            !meta.returnType &&
+            args.descriptor) {
+            meta.returnType = Reflect$2.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);
+            meta.type = Reflect$2.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 }));
+            data.params = (_a = Reflect$2.getOwnMetadata('design:paramtypes', newArgs.target, newArgs.propKey)) === null || _a === void 0 ? void 0 : _a.map((f) => ({ type: f }));
         }
         if (typeof index === 'number') {
             level = 'PARAM';
@@ -436,7 +451,11 @@ class Mate {
                 data = data.params[index];
             }
         }
-        else if (!index && !args.descriptor && args.propKey && this.options.collectPropKeys && args.level !== 'CLASS') {
+        else if (!index &&
+            !args.descriptor &&
+            args.propKey &&
+            this.options.collectPropKeys &&
+            args.level !== 'CLASS') {
             this.set({ ...args, level: 'CLASS' }, (meta) => {
                 if (!meta.properties) {
                     meta.properties = [args.propKey];
@@ -447,7 +466,14 @@ class Mate {
                 return meta;
             });
         }
-        level = typeof index === 'number' ? 'PARAM' : newArgs.propKey && newArgs.descriptor ? 'METHOD' : newArgs.propKey ? 'PROP' : 'CLASS';
+        level =
+            typeof index === 'number'
+                ? 'PARAM'
+                : newArgs.propKey && newArgs.descriptor
+                    ? 'METHOD'
+                    : newArgs.propKey
+                        ? 'PROP'
+                        : 'CLASS';
         if (typeof key !== 'function') {
             if (isArray) {
                 const newArray = (data[key] || []);
@@ -464,14 +490,14 @@ class Mate {
         else if (cb && typeof index !== 'number') {
             meta = cb(data, level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
         }
-        Reflect.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
+        Reflect$2.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
     }
     read(target, propKey) {
         var _a;
         const isConstr = isConstructor(target);
         const constructor = isConstr ? target : getConstructor$1(target);
         const proto = constructor.prototype;
-        let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === 'string' ? proto : constructor, propKey);
+        let ownMeta = Reflect$2.getOwnMetadata(this.workspace, typeof propKey === 'string' ? proto : constructor, propKey);
         if (ownMeta && propKey === undefined && ownMeta.params === undefined) {
             const parent = Object.getPrototypeOf(constructor);
             if (typeof parent === 'function' &&
@@ -487,7 +513,7 @@ class Mate {
             let shouldInherit = this.options.inherit;
             if (inheritFn) {
                 if (typeof propKey === 'string') {
-                    const classMeta = Reflect.getOwnMetadata(this.workspace, constructor);
+                    const classMeta = Reflect$2.getOwnMetadata(this.workspace, constructor);
                     shouldInherit = inheritFn(classMeta, ownMeta, 'PROP', propKey);
                 }
                 else {
@@ -507,8 +533,7 @@ class Mate {
                         ownParams &&
                         (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params)) {
                         for (let i = 0; i < ownParams.length; i++) {
-                            if (typeof (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i]) !==
-                                'undefined') {
+                            if (typeof (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i]) !== 'undefined') {
                                 const ownParam = ownParams[i];
                                 if (ownMeta.params &&
                                     inheritFn &&
@@ -550,7 +575,13 @@ class Mate {
     decorateConditional(ccb) {
         return ((target, propKey, descriptor) => {
             const hasIndex = typeof descriptor === 'number';
-            const decoratorLevel = hasIndex ? 'PARAM' : propKey && descriptor ? 'METHOD' : propKey ? 'PROP' : 'CLASS';
+            const decoratorLevel = hasIndex
+                ? 'PARAM'
+                : propKey && descriptor
+                    ? 'METHOD'
+                    : propKey
+                        ? 'PROP'
+                        : 'CLASS';
             const d = ccb(decoratorLevel);
             if (d) {
                 d(target, propKey, descriptor);
@@ -718,6 +749,11 @@ class Infact {
         this._silent = false;
         this.logger = options.logger || console;
     }
+    _cleanup() {
+        this.registry = {};
+        this.instanceRegistries = new WeakMap();
+        this.scopes = {};
+    }
     setLogger(logger) {
         this.logger = logger;
     }
@@ -1164,6 +1200,1919 @@ const resolvePipe = definePipeFn((_value, metas, level) => {
     },
 ];
 
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var router_cjs_prod = {};
+
+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,
+    };
+}
+
+var cache_esmBundler = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ProstoCache: ProstoCache
+});
+
+var require$$0 = /*@__PURE__*/getAugmentedNamespace(cache_esmBundler);
+
+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;
+}
+
+var tree_esmBundler = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ProstoTree: ProstoTree
+});
+
+function renderCodeFragment(lines, options) {
+    const row = (options.row || 1) - 1;
+    const rowEnd = options.rowEnd ? options.rowEnd - 1 : -1;
+    const limit = Math.min(options.limit || 6, lines.length);
+    const offset = Math.min(options.offset || 3, lines.length);
+    const error = options.error;
+    const errorEnd = options.errorEnd;
+    let output = '';
+    const delta = rowEnd - row;
+    const maxIndex = lines.length;
+    if (delta > limit) {
+        let longestLine = 0;
+        const newLimit = Math.floor(limit / 2);
+        for (let i = 0; i < newLimit + offset; i++) {
+            const index = row + i - offset;
+            const line = lines[index] || '';
+            longestLine = Math.max(line.length, longestLine);
+            output += renderLine(line, index < maxIndex ? index + 1 : '', index === row ? error : undefined, index === row || index === rowEnd ? 'bold' : '');
+        }
+        let output2 = '';
+        for (let i = newLimit + offset; i > 0; i--) {
+            const index = rowEnd - i + offset;
+            const line = lines[index] || '';
+            longestLine = Math.max(line.length, longestLine);
+            output2 += renderLine(line, index < maxIndex ? index + 1 : '', index === rowEnd ? errorEnd : undefined, index === row || index === rowEnd ? 'bold' : '');
+        }
+        output += renderLine('—'.repeat(longestLine), '———', undefined, 'dim') + output2;
+    }
+    else {
+        for (let i = 0; i < limit + offset; i++) {
+            const index = row + i - offset;
+            if (index <= lines.length + 1) {
+                const errorCol = index === row ? error : index === rowEnd ? errorEnd : undefined;
+                output += renderLine(lines[index], index < maxIndex ? index + 1 : '', errorCol, index === row || index === rowEnd ? 'bold' : '');
+            }
+        }
+    }
+    return output;
+}
+function lineStyles(s) {
+    return '' + (s || '')
+        .replace(/([a-z_]+)/ig, '' + '$1' + '\x1b[39;33m')
+        .replace(/([\=\.\/'"`\:\+]+)/ig, '' + '$1' + '');
+}
+function lineStylesError(s) {
+    return '' + (s || '') + '';
+}
+function renderLine(line, index, error, style = '') {
+    const st = (style === 'bold' ? '' : '') + (style === 'dim' ? '' : '');
+    if (typeof error === 'number') {
+        const errorLength = (/[\.-\s\(\)\*\/\+\{\}\[\]\?\'\"\`\<\>]/.exec(line.slice(error + 1)) || { index: line.length - error }).index + 1;
+        return renderLineNumber(index, true) +
+            st +
+            lineStyles(line.slice(0, error)) +
+            lineStylesError(line.slice(error, error + errorLength)) +
+            lineStyles(line.slice(error + errorLength)) +
+            renderLineNumber('', true) + ' '.repeat(error) + '' + '' + '~'.repeat(Math.max(1, errorLength));
+    }
+    return renderLineNumber(index, undefined, style === 'bold') + st + lineStyles(line);
+}
+function renderLineNumber(i, isError = false, bold = false) {
+    let s = '      ';
+    const sep = i === '———';
+    if (i && i > 0 || typeof i === 'string') {
+        s = '      ' + String(i);
+    }
+    s = s.slice(s.length - 5);
+    return '\n' + '' + (sep ? '' : '') +
+        (isError ? '' + '' : (bold ? '' : '')) +
+        s + (sep ? i : ' | ') + '';
+}
+
+function escapeRegex(s) {
+    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+
+class ProstoParserNodeBase {
+    addRecognizes(...args) {
+        for (const node of args) {
+            if (!this.options.recognizes)
+                this.options.recognizes = [];
+            if (!this.options.recognizes.includes(node)) {
+                this.options.recognizes.push(node);
+            }
+        }
+        return this;
+    }
+    addAbsorbs(node, rule = 'append') {
+        this.options.absorbs = this.options.absorbs || {};
+        if (Array.isArray(node)) {
+            node.forEach(n => {
+                this.options.absorbs[n.id] = rule;
+                this.addRecognizes(n);
+            });
+        }
+        else {
+            this.options.absorbs[node.id] = rule;
+            this.addRecognizes(node);
+        }
+        return this;
+    }
+    addPopsAfterNode(...args) {
+        for (const node of args) {
+            if (!this.options.popsAfterNode)
+                this.options.popsAfterNode = [];
+            if (!this.options.popsAfterNode.includes(node)) {
+                this.options.popsAfterNode.push(node);
+            }
+        }
+        this.addRecognizes(...args);
+        return this;
+    }
+    addHoistChildren(...args) {
+        if (!this.options.hoistChildren)
+            this.options.hoistChildren = [];
+        this.options.hoistChildren.push(...args);
+        return this;
+    }
+    set icon(value) {
+        this.options.icon = value;
+    }
+    set label(value) {
+        this.options.label = value;
+    }
+    get startsWith() {
+        return this.options.startsWith;
+    }
+    set startsWith(value) {
+        this.options.startsWith = value;
+    }
+    get endsWith() {
+        return this.options.endsWith;
+    }
+    set endsWith(value) {
+        this.options.endsWith = value;
+    }
+    getPopsAtEOFSource() {
+        return this.options.popsAtEOFSource;
+    }
+    popsAtEOFSource(value) {
+        this.options.popsAtEOFSource = value;
+        return this;
+    }
+    get absorbs() {
+        return this.options.absorbs;
+    }
+    get badToken() {
+        return this.options.badToken;
+    }
+    set badToken(value) {
+        this.options.badToken = value;
+    }
+    get skipToken() {
+        return this.options.skipToken;
+    }
+    set skipToken(value) {
+        this.options.skipToken = value;
+    }
+    get recognizes() {
+        return this.options.recognizes || [];
+    }
+    set recognizes(value) {
+        this.options.recognizes = value;
+    }
+    get hoistChildren() {
+        return this.options.hoistChildren || [];
+    }
+    set hoistChildren(value) {
+        this.options.hoistChildren = value;
+    }
+    getMapContent() {
+        return this.options.mapContent;
+    }
+    mapContent(key, value = 'copy') {
+        this.options.mapContent = this.options.mapContent || {};
+        this.options.mapContent[key] = value;
+        return this;
+    }
+    onMatch(value) {
+        this.options.onMatch = value;
+        return this;
+    }
+    onAppendContent(value) {
+        this.options.onAppendContent = value;
+        return this;
+    }
+    onAfterChildParse(value) {
+        this.options.onAfterChildParse = value;
+        return this;
+    }
+    onBeforeChildParse(value) {
+        this.options.onBeforeChildParse = value;
+        return this;
+    }
+    onMatchStartToken(value) {
+        if (this.options.startsWith) {
+            this.options.startsWith.onMatchToken = value;
+        }
+        return this;
+    }
+    onMatchEndToken(value) {
+        if (this.options.endsWith) {
+            this.options.endsWith.onMatchToken = value;
+        }
+        return this;
+    }
+    initCustomData(value) {
+        this.options.initCustomData = value;
+        return this;
+    }
+    onPop(value) {
+        this.options.onPop = value;
+        return this;
+    }
+    get popsAfterNode() {
+        return this.options.popsAfterNode || [];
+    }
+    set popsAfterNode(nodes) {
+        this.options.popsAfterNode = nodes;
+    }
+    clearStartsWith() {
+        delete this.options.startsWith;
+        return this;
+    }
+    clearEndsWith() {
+        delete this.options.endsWith;
+        return this;
+    }
+    clearPopsAtEOFSource() {
+        delete this.options.popsAtEOFSource;
+        return this;
+    }
+    clearBadToken() {
+        delete this.options.badToken;
+        return this;
+    }
+    clearSkipToken() {
+        delete this.options.skipToken;
+        return this;
+    }
+    clearAbsorbs(node) {
+        if (this.options.absorbs) {
+            if (node && Array.isArray(node)) {
+                for (const n of node) {
+                    delete this.options.absorbs[n.id];
+                }
+            }
+            else if (node) {
+                delete this.options.absorbs[node.id];
+            }
+            else {
+                this.options.absorbs = {};
+            }
+        }
+        return this;
+    }
+    clearRecognizes(...args) {
+        var _a;
+        if (args.length) {
+            this.options.recognizes = (_a = this.options.recognizes) === null || _a === void 0 ? void 0 : _a.filter(n => !args.includes(n));
+        }
+        else {
+            this.options.recognizes = [];
+        }
+        return this;
+    }
+    clearHoistChildren() {
+        delete this.options.hoistChildren;
+        return this;
+    }
+    clearMapContent() {
+        delete this.options.mapContent;
+        return this;
+    }
+    removeOnPop() {
+        delete this.options.onPop;
+        return this;
+    }
+    removeOnMatch() {
+        delete this.options.onMatch;
+        return this;
+    }
+    removeOnAppendContent() {
+        delete this.options.onAppendContent;
+        return this;
+    }
+    removeOnBeforeChildParse() {
+        delete this.options.onBeforeChildParse;
+        return this;
+    }
+    removeOnAfterChildParse() {
+        delete this.options.onAfterChildParse;
+        return this;
+    }
+    fireNodeMatched(matched, cbData) {
+        return this.options.startsWith ? this.fireMatched(this.options.startsWith, matched, cbData) : { confirmed: true };
+    }
+    fireNodeEndMatched(matched, cbData) {
+        return this.options.endsWith ? this.fireMatched(this.options.endsWith, matched, cbData) : { confirmed: true };
+    }
+    fireMatched(descr, matched, cbData) {
+        const { omit, eject, onMatchToken } = descr;
+        let cbResult = true;
+        if (onMatchToken) {
+            cbResult = onMatchToken({
+                ...cbData,
+                matched,
+            });
+        }
+        const cbOmit = typeof cbResult === 'object' ? cbResult.omit : undefined;
+        const cbEject = typeof cbResult === 'object' ? cbResult.eject : undefined;
+        return {
+            omit: cbOmit !== undefined ? cbOmit : omit,
+            eject: cbEject !== undefined ? cbEject : eject,
+            confirmed: cbResult !== false,
+        };
+    }
+    getStartTokenRg() {
+        return this.getRgOutOfTokenDescriptor(this.options.startsWith);
+    }
+    getEndTokenRg() {
+        return this.getRgOutOfTokenDescriptor(this.options.endsWith);
+    }
+    getConstraintTokens() {
+        return {
+            skip: this.getRgOutOfTokenDescriptor(this.options.skipToken ? { token: this.options.skipToken } : undefined) || undefined,
+            bad: this.getRgOutOfTokenDescriptor(this.options.badToken ? { token: this.options.badToken } : undefined) || undefined,
+        };
+    }
+    getRgOutOfTokenDescriptor(descr) {
+        if (descr) {
+            const prefix = descr.ignoreBackSlashed ? /(?<=(?:^|[^\\])(?:\\\\)*)/.source : '';
+            let token;
+            if (typeof descr.token === 'function') {
+                token = descr.token(this);
+            }
+            else {
+                token = descr.token;
+            }
+            if (token instanceof RegExp) {
+                return new RegExp(prefix + token.source, token.flags);
+            }
+            else {
+                return new RegExp(`${prefix}(?:${[token].flat().map(t => escapeRegex(t)).join('|')})`);
+            }
+        }
+    }
+}
+
+class ProstoHoistManager {
+    constructor() {
+        this.data = {};
+    }
+    addHoistOptions(ctx) {
+        if (ctx.hoistChildren) {
+            ctx.hoistChildren.forEach(options => {
+                const nodeId = typeof options.node === 'object' ? options.node.id : options.node;
+                const hoist = this.data[nodeId] = (this.data[nodeId] || {});
+                if (hoist) {
+                    hoist[ctx.index] = {
+                        options,
+                        context: ctx,
+                    };
+                }
+            });
+        }
+    }
+    removeHoistOptions(ctx) {
+        if (ctx.hoistChildren) {
+            ctx.hoistChildren.forEach(options => {
+                const nodeId = typeof options.node === 'object' ? options.node.id : options.node;
+                const hoist = this.data[nodeId];
+                if (hoist) {
+                    delete hoist[ctx.index];
+                }
+            });
+        }
+    }
+    processHoistOptions(ctx) {
+        const id = ctx.node.id;
+        const hoist = this.data[id];
+        if (hoist) {
+            Object.keys(hoist).map(i => hoist[i]).forEach(({ options, context }) => {
+                const customData = context.getCustomData();
+                if (options.deep === true || Number(options.deep) >= (ctx.level - context.level)) {
+                    if (options.asArray) {
+                        const hoisted = customData[options.as] = (customData[options.as] || []);
+                        if (!Array.isArray(hoisted)) {
+                            if (!options.onConflict || options.onConflict === 'error') {
+                                throw new Error(`Can not hoist "${ctx.node.name}" to "${context.node.name}" as "${options.as}". "${options.as}" already exists and it is not an Array Type.`);
+                            }
+                            else if (options.onConflict === 'overwrite') {
+                                customData[options.as] = [doTheMapRule(options, ctx)];
+                            }
+                            else if (options.onConflict !== 'ignore') {
+                                throw new Error(`Unsupported hoisting option onConflict "${options.onConflict}"`);
+                            }
+                        }
+                        else {
+                            hoisted.push(doTheMapRule(options, ctx));
+                        }
+                    }
+                    else {
+                        if (customData[options.as]) {
+                            if (!options.onConflict || options.onConflict === 'error') {
+                                throw new Error(`Can not hoist multiple "${ctx.node.name}" to "${context.node.name}" as "${options.as}". "${options.as}" already exists.`);
+                            }
+                            else if (options.onConflict === 'overwrite') {
+                                customData[options.as] = doTheMapRule(options, ctx);
+                            }
+                            else if (options.onConflict !== 'ignore') {
+                                throw new Error(`Unsupported hoisting option onConflict "${options.onConflict}"`);
+                            }
+                        }
+                        else {
+                            customData[options.as] = doTheMapRule(options, ctx);
+                        }
+                    }
+                    if (options.removeChildFromContent) {
+                        context.content = context.content.filter(c => c !== ctx);
+                    }
+                }
+            });
+        }
+        function doTheMapRule(options, ctx) {
+            var _a;
+            if (typeof options.mapRule === 'function') {
+                return options.mapRule(ctx);
+            }
+            if (options.mapRule === 'content.join') {
+                return ctx.content.join('');
+            }
+            if ((_a = options.mapRule) === null || _a === void 0 ? void 0 : _a.startsWith('customData')) {
+                const key = options.mapRule.slice(11);
+                if (key) {
+                    return ctx.getCustomData()[key];
+                }
+                else {
+                    return ctx.getCustomData();
+                }
+            }
+            return ctx;
+        }
+    }
+}
+
+const banner = '' + '[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 + '', 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 + '', 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');
+        }
+    }
+}
+
+var parser_esmBundler = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  BasicNode: BasicNode,
+  ProstoParserContext: ProstoParserContext,
+  ProstoParserNode: ProstoParserNode,
+  ProstoParserNodeContext: ProstoParserNodeContext,
+  renderCodeFragment: renderCodeFragment
+});
+
+var require$$1 = /*@__PURE__*/getAugmentedNamespace(parser_esmBundler);
+
+var require$$2 = /*@__PURE__*/getAugmentedNamespace(tree_esmBundler);
+
+(function (exports) {
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+	var cache = require$$0;
+	var parser$1 = require$$1;
+	var tree = require$$2;
+
+	function parsePath(expr) {
+	    return parser.parse(expr).extractCustomDataTree();
+	}
+	class ParametricNodeWithRegex extends parser$1.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('name', 'join')
+	            .mapContent('value', content => content.shift())
+	            .popsAtEOFSource(true)
+	            .addRecognizes(rgNode)
+	            .addPopsAfterNode(rgNode)
+	            .addHoistChildren(hoistRegex);
+	    }
+	    beforeOnPop(data) {
+	        if (data.customData.name.endsWith('?')) {
+	            data.customData.name = data.customData.name.slice(0, -1);
+	            data.customData.value = data.customData.name;
+	            data.customData.optional = true;
+	        }
+	        else if (data.parserContext.here[0] === '?') {
+	            data.customData.optional = true;
+	            data.parserContext.jump();
+	        }
+	    }
+	}
+	const regexNode = new parser$1.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: exports.EPathSegmentType.VARIABLE, value: '', regex: '([^\\/]*)', name: '' }));
+	const wildcardNode = new ParametricNodeWithRegex({
+	    label: 'Wildcard',
+	    tokens: ['*', /[^*\()]/],
+	    tokenOE: '-eject',
+	}, regexNode).initCustomData(() => ({ type: exports.EPathSegmentType.WILDCARD, value: '*', regex: '(.*)', name: '' }));
+	const staticNode = new parser$1.BasicNode({
+	    label: 'Static',
+	    tokens: [/[^:\*]/, /[:\*]/],
+	    backSlash: '-ignore',
+	    tokenOE: '-eject',
+	}).initCustomData(() => ({ type: exports.EPathSegmentType.STATIC, value: '' }))
+	    .mapContent('value', content => content.splice(0).join('').replace(/\\:/g, ':'))
+	    .popsAtEOFSource(true);
+	const parser = new parser$1.BasicNode({}).addRecognizes(staticNode, paramNode, wildcardNode);
+
+	exports.EPathSegmentType = void 0;
+	(function (EPathSegmentType) {
+	    EPathSegmentType[EPathSegmentType["STATIC"] = 0] = "STATIC";
+	    EPathSegmentType[EPathSegmentType["VARIABLE"] = 1] = "VARIABLE";
+	    EPathSegmentType[EPathSegmentType["REGEX"] = 2] = "REGEX";
+	    EPathSegmentType[EPathSegmentType["WILDCARD"] = 3] = "WILDCARD";
+	})(exports.EPathSegmentType || (exports.EPathSegmentType = {}));
+
+	function safeDecode(f, v) {
+	    try {
+	        return f(v);
+	    }
+	    catch (e) {
+	        return v;
+	    }
+	}
+	function safeDecodeURIComponent(uri) {
+	    if (!uri || uri.indexOf('%') < 0)
+	        return uri;
+	    return safeDecode(decodeURIComponent, uri);
+	}
+	function safeDecodeURI(uri) {
+	    if (!uri || 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 = '';
+	    let optional = false;
+	    segments.forEach(segment => {
+	        switch (segment.type) {
+	            case exports.EPathSegmentType.STATIC:
+	                if (optional) {
+	                    if (['-', '/'].includes(segment.value)) {
+	                        regex += escapeRegex(segment.value) + '?';
+	                    }
+	                    else {
+	                        throw new Error(`Static route segment "${segment.value}" is not allowed after optional parameters.`);
+	                    }
+	                }
+	                else {
+	                    regex += escapeRegex(segment.value);
+	                }
+	                break;
+	            case exports.EPathSegmentType.VARIABLE:
+	            case exports.EPathSegmentType.WILDCARD:
+	                if (optional && !segment.optional)
+	                    throw new Error('Obligatory route parameters are not allowed after optional parameters. Use "?" to mark it as an optional route parameter.');
+	                if (segment.optional && !optional) {
+	                    if (regex.endsWith('/')) {
+	                        regex += '?';
+	                    }
+	                }
+	                regex += nonCapturing ? segment.regex.replace(/^\(/, '(?:') : segment.regex;
+	                if (segment.optional) {
+	                    optional = true;
+	                    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 exports.EPathSegmentType.VARIABLE:
+	            case exports.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 exports.EPathSegmentType.VARIABLE:
+	            case exports.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 exports.EPathSegmentType.STATIC:
+	                str.append(segment.value.replace(/`/g, '\\`'));
+	                break;
+	            case exports.EPathSegmentType.VARIABLE:
+	            case exports.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 = () => `[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 cache.ProstoCache(cacheOpts),
+	                PUT: new cache.ProstoCache(cacheOpts),
+	                POST: new cache.ProstoCache(cacheOpts),
+	                PATCH: new cache.ProstoCache(cacheOpts),
+	                DELETE: new cache.ProstoCache(cacheOpts),
+	                HEAD: new cache.ProstoCache(cacheOpts),
+	                OPTIONS: new cache.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 exports.EPathSegmentType.STATIC: return s.value;
+	                case exports.EPathSegmentType.VARIABLE: return '<VAR' + (s.regex === '([^-\\/]*)' ? '' : s.regex) + '>';
+	                case exports.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 === exports.EPathSegmentType.STATIC || segments.length === 0;
+	            const isParametric = !!segments.find(p => p.type === exports.EPathSegmentType.VARIABLE);
+	            const firstOptional = segments.findIndex(p => p.optional);
+	            const isOptional = firstOptional >= 0;
+	            const isWildcard = !!segments.find(p => p.type === exports.EPathSegmentType.WILDCARD);
+	            const lengths = segments.slice(0, firstOptional >= 0 ? firstOptional : undefined).map(s => s.type === exports.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,
+	                isOptional,
+	                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 && !route.isOptional) {
+	                    const countOfParts = route.segments
+	                        .filter(s => s.type === exports.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 || route.isOptional) {
+	                    if (route.isOptional && route.firstStatic.endsWith('/')) {
+	                        route.firstStatic = route.firstStatic.slice(0, -1);
+	                        route.firstLength--;
+	                        route.minLength = Math.min(route.minLength, route.firstLength);
+	                    }
+	                    rootMethod.wildcards.push(route);
+	                    rootMethod.wildcards = rootMethod.wildcards.sort(routeSorter);
+	                }
+	            }
+	        }
+	        return {
+	            getPath: route.pathBuilder,
+	            getArgs: () => route.segments.filter(p => p.type === exports.EPathSegmentType.VARIABLE || p.type === exports.EPathSegmentType.WILDCARD).map(s => s.name),
+	            getStaticPart: () => route.firstStatic,
+	            test: route.fullMatch,
+	            isStatic: route.isStatic,
+	            isParametric: route.isParametric,
+	            isWildcard: route.isWildcard,
+	            generalized,
+	        };
+	    }
+	    mergeOptions(options) {
+	        return {
+	            ...options,
+	        };
+	    }
+	    sanitizePath(path, ignoreTrailingSlash) {
+	        const end = path.indexOf('?');
+	        let slicedPath = end >= 0 ? path.slice(0, end) : path;
+	        if ((ignoreTrailingSlash || 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, ignoreTrailingSlash) {
+	        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, ignoreTrailingSlash);
+	        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 => {
+	                let parts;
+	                switch (s.type) {
+	                    case exports.EPathSegmentType.STATIC:
+	                        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 exports.EPathSegmentType.VARIABLE:
+	                    case exports.EPathSegmentType.WILDCARD:
+	                        last += `${paramStyle(s.value)}${regexStyle(s.regex)}`;
+	                }
+	            });
+	            if (last) {
+	                cur = toChild(cur, last, handlerStyle);
+	                cur.methods.push(route.method);
+	            }
+	        });
+	        new tree.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() + v + '');
+	}
+	function consoleWarn(v) {
+	    console.info('' + banner() + v + '');
+	}
+	function consoleInfo(v) {
+	    console.info('' + '' + banner() + v + '' + '');
+	}
+
+	exports.ProstoRouter = ProstoRouter;
+	exports.escapeRegex = escapeRegex;
+	exports.safeDecodeURI = safeDecodeURI;
+	exports.safeDecodeURIComponent = safeDecodeURIComponent; 
+} (router_cjs_prod));
+
 function getOtelMate() {
     return getMoostMate();
 }