@moostjs/otel 0.5.21 → 0.5.22

package/dist/index.cjs

@@ -1,2636 +1,368 @@
-'use strict';
-
-var api = require('@opentelemetry/api');
-var moost = require('moost');
-require('crypto');
-var node_async_hooks = require('node:async_hooks');
-var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
-
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __opentelemetry_api = __toESM(require("@opentelemetry/api"));
+const moost = __toESM(require("moost"));
+const __opentelemetry_sdk_trace_base = __toESM(require("@opentelemetry/sdk-trace-base"));
+
+//#region packages/otel/src/context.ts
 const spanStack = [];
 function useOtelContext() {
-    const eventContext = moost.useAsyncEventContext();
-    const store = eventContext.store('otel');
-    const csa = eventContext.store('customSpanAttrs');
-    const cma = eventContext.store('customMetricAttrs');
-    const customSpanAttr = (name, value) => csa.set(name, value);
-    const customMetricAttr = (name, value) => cma.set(name, value);
-    const getSpan = () => store.get('span');
-    const getSpanContext = () => {
-        const span = getSpan();
-        if (span) {
-            return span.spanContext();
-        }
-    };
-    const getPropagationHeaders = () => {
-        const c = getSpanContext();
-        if (c) {
-            return {
-                traceparent: `00-${c.traceId}-${c.spanId}-${c.traceFlags}`,
-                tracestate: c.traceState,
-            };
-        }
-        return {};
-    };
-    const pushSpan = (span) => {
-        const activeSpan = api.trace.getActiveSpan();
-        if (activeSpan) {
-            const origEnd = activeSpan.end;
-            Object.assign(activeSpan, {
-                end: (t) => {
-                    popSpan();
-                    const i = spanStack.indexOf(activeSpan);
-                    if (i >= 0) {
-                        spanStack.splice(i, 1);
-                    }
-                    origEnd.apply(span, [t]);
-                },
-            });
-            spanStack.push(activeSpan);
-        }
-        api.trace.setSpan(api.context.active(), span);
-    };
-    const popSpan = () => {
-        const span = spanStack.pop();
-        if (span) {
-            api.trace.setSpan(api.context.active(), span);
-        }
-    };
-    return {
-        trace: api.trace,
-        withChildSpan: (name, cb, opts) => {
-            const tracer = api.trace.getTracer('moost-tracer');
-            const span = tracer.startSpan(name, opts);
-            return () => api.context.with(api.trace.setSpan(api.context.active(), span), cb);
-        },
-        getSpan,
-        getSpanContext,
-        getPropagationHeaders,
-        registerSpan: (span) => store.set('span', span),
-        pushSpan,
-        customSpanAttr,
-        customMetricAttr,
-    };
+	const eventContext = (0, moost.useAsyncEventContext)();
+	const store = eventContext.store("otel");
+	const csa = eventContext.store("customSpanAttrs");
+	const cma = eventContext.store("customMetricAttrs");
+	const customSpanAttr = (name, value) => csa.set(name, value);
+	const customMetricAttr = (name, value) => cma.set(name, value);
+	const getSpan = () => store.get("span");
+	const getSpanContext = () => {
+		const span = getSpan();
+		if (span) return span.spanContext();
+	};
+	const getPropagationHeaders = () => {
+		const c = getSpanContext();
+		if (c) return {
+			traceparent: `00-${c.traceId}-${c.spanId}-${c.traceFlags}`,
+			tracestate: c.traceState
+		};
+		return {};
+	};
+	const pushSpan = (span) => {
+		const activeSpan = __opentelemetry_api.trace.getActiveSpan();
+		if (activeSpan) {
+			const origEnd = activeSpan.end;
+			Object.assign(activeSpan, { end: (t) => {
+				popSpan();
+				const i = spanStack.indexOf(activeSpan);
+				if (i >= 0) spanStack.splice(i, 1);
+				origEnd.apply(span, [t]);
+			} });
+			spanStack.push(activeSpan);
+		}
+		__opentelemetry_api.trace.setSpan(__opentelemetry_api.context.active(), span);
+	};
+	const popSpan = () => {
+		const span = spanStack.pop();
+		if (span) __opentelemetry_api.trace.setSpan(__opentelemetry_api.context.active(), span);
+	};
+	return {
+		trace: __opentelemetry_api.trace,
+		withChildSpan: (name, cb, opts) => {
+			const tracer$1 = __opentelemetry_api.trace.getTracer("moost-tracer");
+			const span = tracer$1.startSpan(name, opts);
+			return () => __opentelemetry_api.context.with(__opentelemetry_api.trace.setSpan(__opentelemetry_api.context.active(), span), cb);
+		},
+		getSpan,
+		getSpanContext,
+		getPropagationHeaders,
+		registerSpan: (span) => store.set("span", span),
+		pushSpan,
+		customSpanAttr,
+		customMetricAttr
+	};
 }
 function useTrace() {
-    return api.trace;
+	return __opentelemetry_api.trace;
 }
 function useSpan() {
-    return useOtelContext().getSpan();
+	return useOtelContext().getSpan();
 }
 function useOtelPropagation() {
-    const { getPropagationHeaders, getSpanContext } = useOtelContext();
-    return {
-        ...getSpanContext(),
-        headers: getPropagationHeaders(),
-    };
+	const { getPropagationHeaders, getSpanContext } = useOtelContext();
+	return {
+		...getSpanContext(),
+		headers: getPropagationHeaders()
+	};
 }
 
+//#endregion
+//#region packages/otel/src/metrics.ts
 let moostMetrics;
 function getMoostMetrics() {
-    if (!moostMetrics) {
-        const meter = api.metrics.getMeter('moost-meter');
-        moostMetrics = {
-            moostEventDuration: meter.createHistogram('moost.event.duration', {
-                description: 'Moost Event Duration Histogram',
-                unit: 'ms',
-            }),
-        };
-    }
-    return moostMetrics;
+	if (!moostMetrics) {
+		const meter = __opentelemetry_api.metrics.getMeter("moost-meter");
+		moostMetrics = { moostEventDuration: meter.createHistogram("moost.event.duration", {
+			description: "Moost Event Duration Histogram",
+			unit: "ms"
+		}) };
+	}
+	return moostMetrics;
 }
 
+//#endregion
+//#region packages/otel/src/utils.ts
 function withSpan(span, cb, postProcess) {
-    const _span = typeof span.name === 'string' && !span.spanContext
-        ? api.trace
-            .getTracer('default')
-            .startSpan(span.name, span.options)
-        : span;
-    let result = undefined;
-    const finalizeSpan = (e, r) => {
-        if (e) {
-            _span.recordException(e);
-            _span.setStatus({
-                code: api.SpanStatusCode.ERROR,
-                message: e.message || 'Unknown Error',
-            });
-        }
-        if (postProcess) {
-            postProcess(_span, e, r);
-        }
-        else {
-            _span.end();
-        }
-    };
-    api.context.with(api.trace.setSpan(api.context.active(), _span), () => {
-        try {
-            result = cb();
-        }
-        catch (error) {
-            finalizeSpan(error, undefined);
-            throw error;
-        }
-        if (result instanceof Promise) {
-            result
-                .then(r => {
-                finalizeSpan(undefined, r);
-                return r;
-            })
-                .catch(error => {
-                finalizeSpan(error, undefined);
-            });
-        }
-        else {
-            finalizeSpan(undefined, result);
-        }
-    });
-    return result;
-}
-
-const tracer = api.trace.getTracer('moost-tracer');
-class SpanInjector extends moost.ContextInjector {
-    constructor() {
-        super(...arguments);
-        this.metrics = getMoostMetrics();
-    }
-    with(name, attributes, cb) {
-        const fn = typeof attributes === 'function' ? attributes : cb;
-        const attrs = typeof attributes === 'object' ? attributes : undefined;
-        if (name === 'Event:start' && attrs?.eventType) {
-            return this.startEvent(attrs.eventType, fn);
-        }
-        else if (name !== 'Event:start') {
-            if (this.getIgnoreSpan()) {
-                return fn();
-            }
-            else {
-                const span = tracer.startSpan(name, {
-                    kind: api.SpanKind.INTERNAL,
-                    attributes: attrs,
-                });
-                return this.withSpan(span, fn, {
-                    withMetrics: false,
-                    endSpan: true,
-                });
-            }
-        }
-        return fn();
-    }
-    patchRsponse() {
-        const res = this.getResponse();
-        if (res) {
-            const originalWriteHead = res.writeHead;
-            Object.assign(res, {
-                writeHead: (arg0, arg1, arg2) => {
-                    res._statusCode = arg0;
-                    const headers = typeof arg2 === 'object' ? arg2 : typeof arg1 === 'object' ? arg1 : undefined;
-                    res._contentLength = headers?.['content-length'] ? Number(headers['content-length']) : 0;
-                    return originalWriteHead.apply(res, [arg0, arg1, arg2]);
-                },
-            });
-        }
-    }
-    startEvent(eventType, cb) {
-        if (eventType === 'init') {
-            return cb();
-        }
-        const { registerSpan } = useOtelContext();
-        let span = api.trace.getActiveSpan();
-        if (eventType === 'HTTP') {
-            this.patchRsponse();
-        }
-        else {
-            span = tracer.startSpan(`${eventType} Event`);
-        }
-        if (span) {
-            registerSpan(span);
-            return this.withSpan(span, cb, {
-                withMetrics: true,
-                endSpan: eventType !== 'HTTP',
-            });
-        }
-        return cb();
-    }
-    getEventType() {
-        return moost.useAsyncEventContext().getCtx().event.type;
-    }
-    getIgnoreSpan() {
-        const { getMethodMeta, getControllerMeta } = moost.useControllerContext();
-        const cMeta = getControllerMeta();
-        const mMeta = getMethodMeta();
-        return cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan;
-    }
-    getControllerHandlerMeta() {
-        const { getMethod, getMethodMeta, getController, getControllerMeta, getRoute } = moost.useControllerContext();
-        const methodName = getMethod();
-        const controller = getController();
-        const cMeta = controller ? getControllerMeta() : undefined;
-        const mMeta = controller ? getMethodMeta() : undefined;
-        return {
-            ignoreMeter: cMeta?.otelIgnoreMeter || mMeta?.otelIgnoreMeter,
-            ignoreSpan: cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan,
-            attrs: {
-                'moost.controller': controller ? moost.getConstructor(controller).name : undefined,
-                'moost.handler': methodName,
-                'moost.handler_description': mMeta?.description,
-                'moost.handler_label': mMeta?.label,
-                'moost.handler_id': mMeta?.id,
-                'moost.ignore': cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan,
-                'moost.route': getRoute(),
-                'moost.event_type': this.getEventType(),
-            },
-        };
-    }
-    hook(method, name, route) {
-        if (method === 'WF_STEP') {
-            return;
-        }
-        if (method === '__SYSTEM__') {
-            return;
-        }
-        const { getSpan } = useOtelContext();
-        if (name === 'Handler:not_found') {
-            const chm = this.getControllerHandlerMeta();
-            const span = getSpan();
-            if (span) {
-                const eventType = this.getEventType();
-                if (eventType === 'HTTP') {
-                    const req = this.getRequest();
-                    span.updateName(`${req?.method || ''} ${req?.url}`);
-                }
-            }
-            this.startEventMetrics(chm.attrs, route);
-        }
-        else if (name === 'Controller:registered') {
-            const _route = moost.useAsyncEventContext().store('otel').get('route');
-            const chm = this.getControllerHandlerMeta();
-            if (!chm.ignoreMeter) {
-                this.startEventMetrics(chm.attrs, _route);
-            }
-            const span = getSpan();
-            if (span) {
-                span.setAttributes(chm.attrs);
-                if (chm.attrs['moost.event_type'] === 'HTTP') {
-                    span.updateName(`${this.getRequest()?.method || ''} ${_route || '<unresolved>'}`);
-                }
-                else {
-                    span.updateName(`${chm.attrs['moost.event_type']} ${_route || '<unresolved>'}`);
-                }
-            }
-        }
-        if (name !== 'Controller:registered') {
-            moost.useAsyncEventContext().store('otel').set('route', route);
-        }
-    }
-    withSpan(span, cb, opts) {
-        return withSpan(span, cb, (_span, exception, result) => {
-            if (result instanceof Error) {
-                _span.recordException(result);
-            }
-            if (opts.withMetrics) {
-                const chm = this.getControllerHandlerMeta();
-                if (!chm.ignoreMeter) {
-                    this.endEventMetrics(chm.attrs, result instanceof Error ? result : exception);
-                }
-            }
-            if (opts.endSpan) {
-                const customAttrs = moost.useAsyncEventContext().store('customSpanAttrs').value;
-                if (customAttrs) {
-                    _span.setAttributes(customAttrs);
-                }
-                _span.end();
-            }
-        });
-    }
-    startEventMetrics(a, route) {
-        moost.useAsyncEventContext().store('otel').set('startTime', Date.now());
-    }
-    endEventMetrics(a, error) {
-        const otelStore = moost.useAsyncEventContext().store('otel');
-        const route = otelStore.get('route');
-        const duration = Date.now() - (otelStore.get('startTime') || Date.now() - 1);
-        const customAttrs = moost.useAsyncEventContext().store('customMetricAttrs').value || {};
-        const attrs = {
-            ...customAttrs,
-            route,
-            'moost.event_type': a['moost.event_type'],
-            'moost.is_error': error ? 1 : 0,
-        };
-        if (a['moost.event_type'] === 'HTTP') {
-            if (!attrs.route) {
-                attrs.route = this.getRequest()?.url || '';
-            }
-            attrs['http.status_code'] = this.getResponse()?._statusCode || 0;
-            attrs['moost.is_error'] = attrs['moost.is_error'] || attrs['http.status_code'] > 399 ? 1 : 0;
-        }
-        this.metrics.moostEventDuration.record(duration, attrs);
-    }
-    getRequest() {
-        return moost.useAsyncEventContext().store('event').get('req');
-    }
-    getResponse() {
-        return moost.useAsyncEventContext()
-            .store('event')
-            .get('res');
-    }
-}
-
-function enableOtelForMoost() {
-    moost.replaceContextInjector(new SpanInjector());
-}
-
-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;
-}
-
-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';
-    const metadata = isParam ? paramMetadata : classMetadata;
-    const targetKey = getConstructor(target);
-    let meta = metadata.get(targetKey);
-    if (!meta) {
-        meta = {};
-        metadata.set(targetKey, meta);
-    }
-    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);
-        });
-    },
-    _cleanup: (() => {
-        classMetadata = new WeakMap();
-        paramMetadata = new WeakMap();
-    }),
-};
-if (!root.Reflect) {
-    root.Reflect = _reflect;
-}
-else {
-    const funcs = [
-        'getOwnMetadata',
-        'defineMetadata',
-        'metadata',
-    ];
-    const target = root.Reflect;
-    for (const func of funcs) {
-        if (typeof target[func] !== 'function') {
-            Object.defineProperty(target, func, { configurable: true, writable: true, value: _reflect[func] });
-        }
-    }
-}
-const Reflect$1 = _reflect;
-
-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 }
-                : args;
-        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$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$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';
-            data.params = data.params || [];
-            data.params[index] = data.params[index] || {
-                type: undefined,
-            };
-            if (cb) {
-                data.params[index] = cb(data.params[index], level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
-            }
-            else {
-                data = data.params[index];
-            }
-        }
-        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];
-                }
-                else if (!meta.properties.includes(args.propKey)) {
-                    meta.properties.push(args.propKey);
-                }
-                return meta;
-            });
-        }
-        level =
-            typeof index === 'number'
-                ? 'PARAM'
-                : newArgs.propKey && newArgs.descriptor
-                    ? 'METHOD'
-                    : newArgs.propKey
-                        ? 'PROP'
-                        : 'CLASS';
-        if (typeof key !== 'function') {
-            if (isArray) {
-                const newArray = (data[key] || []);
-                if (!Array.isArray(newArray)) {
-                    this.logger.error('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, level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
-        }
-        Reflect$2.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
-    }
-    read(target, propKey) {
-        var _a;
-        const isConstr = isConstructor(target);
-        const constructor = isConstr ? target : getConstructor(target);
-        const proto = constructor.prototype;
-        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' &&
-                parent !== fnProto &&
-                parent !== constructor) {
-                ownMeta.params = (_a = this.read(parent)) === null || _a === void 0 ? void 0 : _a.params;
-            }
-        }
-        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$2.getOwnMetadata(this.workspace, constructor);
-                    shouldInherit = inheritFn(classMeta, ownMeta, 'PROP', propKey);
-                }
-                else {
-                    shouldInherit = inheritFn(ownMeta, ownMeta, 'CLASS');
-                }
-            }
-            if (shouldInherit) {
-                const parent = Object.getPrototypeOf(constructor);
-                if (typeof parent === 'function' &&
-                    parent !== fnProto &&
-                    parent !== constructor) {
-                    const inheritedMeta = (this.read(parent, propKey) ||
-                        {});
-                    const ownParams = ownMeta === null || ownMeta === void 0 ? void 0 : ownMeta.params;
-                    ownMeta = { ...inheritedMeta, ...ownMeta };
-                    if (typeof propKey === 'string' &&
-                        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') {
-                                const ownParam = ownParams[i];
-                                if (ownMeta.params &&
-                                    inheritFn &&
-                                    inheritFn(ownMeta, ownParam, 'PARAM', typeof propKey === 'string'
-                                        ? propKey
-                                        : undefined)) {
-                                    ownMeta.params[i] = {
-                                        ...inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i],
-                                        ...ownParams[i],
-                                    };
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        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);
-        });
-    }
-    decorateConditional(ccb) {
-        return ((target, propKey, descriptor) => {
-            const hasIndex = typeof descriptor === 'number';
-            const decoratorLevel = hasIndex
-                ? 'PARAM'
-                : propKey && descriptor
-                    ? 'METHOD'
-                    : propKey
-                        ? 'PROP'
-                        : 'CLASS';
-            const d = ccb(decoratorLevel);
-            if (d) {
-                d(target, propKey, descriptor);
-            }
-        });
-    }
-    decorateClass(key, value, isArray) {
-        return this.decorate(key, value, isArray, 'CLASS');
-    }
-}
-const fnProto = Object.getPrototypeOf(Function);
-
-const defaultLevels = [
-    'fatal',
-    'error',
-    'warn',
-    'log',
-    'info',
-    'debug',
-    'trace',
-];
-const defaultMappedLevels = new Map();
-defaultLevels.forEach((type, level) => defaultMappedLevels.set(type, level));
-
-new node_async_hooks.AsyncLocalStorage();
-
-const METADATA_WORKSPACE = 'moost';
-const moostMate = new Mate(METADATA_WORKSPACE, {
-    readType: true,
-    readReturnType: true,
-    collectPropKeys: true,
-    inherit(classMeta, targetMeta, level) {
-        if (level === 'CLASS') {
-            return !!classMeta?.inherit;
-        }
-        if (level === 'PROP') {
-            return !!targetMeta?.inherit || !!(classMeta?.inherit && !targetMeta);
-        }
-        return !!targetMeta?.inherit;
-    },
-});
-function getMoostMate() {
-    return moostMate;
+	const _span = typeof span.name === "string" && !span.spanContext ? __opentelemetry_api.trace.getTracer("default").startSpan(span.name, span.options) : span;
+	let result = undefined;
+	const finalizeSpan = (e, r) => {
+		if (e) {
+			_span.recordException(e);
+			_span.setStatus({
+				code: __opentelemetry_api.SpanStatusCode.ERROR,
+				message: e.message || "Unknown Error"
+			});
+		}
+		if (postProcess) postProcess(_span, e, r);
+		else _span.end();
+	};
+	__opentelemetry_api.context.with(__opentelemetry_api.trace.setSpan(__opentelemetry_api.context.active(), _span), () => {
+		try {
+			result = cb();
+		} catch (error) {
+			finalizeSpan(error, undefined);
+			throw error;
+		}
+		if (result instanceof Promise) result.then((r) => {
+			finalizeSpan(undefined, r);
+			return r;
+		}).catch((error) => {
+			finalizeSpan(error, undefined);
+		});
+		else finalizeSpan(undefined, result);
+	});
+	return result;
 }
 
-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 = {}));
-
-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 = {}));
-
-function definePipeFn(fn, priority = TPipePriority.TRANSFORM) {
-    fn.priority = priority;
-    return fn;
+//#endregion
+//#region packages/otel/src/span-injector.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+	else obj[key] = value;
+	return obj;
 }
-
-const resolvePipe = definePipeFn((_value, metas, level) => {
-    const resolver = metas.targetMeta?.resolver;
-    if (resolver) {
-        return resolver(metas, level);
-    }
-    return undefined;
-}, TPipePriority.RESOLVE);
-
-[
-    {
-        handler: resolvePipe,
-        priority: TPipePriority.RESOLVE,
-    },
-];
-
-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);
+const tracer = __opentelemetry_api.trace.getTracer("moost-tracer");
+var SpanInjector = class extends moost.ContextInjector {
+	with(name, attributes, cb) {
+		const fn = typeof attributes === "function" ? attributes : cb;
+		const attrs = typeof attributes === "object" ? attributes : undefined;
+		if (name === "Event:start" && attrs?.eventType) return this.startEvent(attrs.eventType, fn);
+		else if (name !== "Event:start") if (this.getIgnoreSpan()) return fn();
+		else {
+			const span = tracer.startSpan(name, {
+				kind: __opentelemetry_api.SpanKind.INTERNAL,
+				attributes: attrs
+			});
+			return this.withSpan(span, fn, {
+				withMetrics: false,
+				endSpan: true
+			});
+		}
+		return fn();
+	}
+	patchRsponse() {
+		const res = this.getResponse();
+		if (res) {
+			const originalWriteHead = res.writeHead;
+			Object.assign(res, { writeHead: (arg0, arg1, arg2) => {
+				res._statusCode = arg0;
+				const headers = typeof arg2 === "object" ? arg2 : typeof arg1 === "object" ? arg1 : undefined;
+				res._contentLength = headers?.["content-length"] ? Number(headers["content-length"]) : 0;
+				return originalWriteHead.apply(res, [
+					arg0,
+					arg1,
+					arg2
+				]);
+			} });
+		}
+	}
+	startEvent(eventType, cb) {
+		if (eventType === "init") return cb();
+		const { registerSpan } = useOtelContext();
+		let span = __opentelemetry_api.trace.getActiveSpan();
+		if (eventType === "HTTP") this.patchRsponse();
+		else span = tracer.startSpan(`${eventType} Event`);
+		if (span) {
+			registerSpan(span);
+			return this.withSpan(span, cb, {
+				withMetrics: true,
+				endSpan: eventType !== "HTTP"
+			});
+		}
+		return cb();
+	}
+	getEventType() {
+		return (0, moost.useAsyncEventContext)().getCtx().event.type;
+	}
+	getIgnoreSpan() {
+		const { getMethodMeta, getControllerMeta } = (0, moost.useControllerContext)();
+		const cMeta = getControllerMeta();
+		const mMeta = getMethodMeta();
+		return cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan;
+	}
+	getControllerHandlerMeta() {
+		const { getMethod, getMethodMeta, getController, getControllerMeta, getRoute } = (0, moost.useControllerContext)();
+		const methodName = getMethod();
+		const controller = getController();
+		const cMeta = controller ? getControllerMeta() : undefined;
+		const mMeta = controller ? getMethodMeta() : undefined;
+		return {
+			ignoreMeter: cMeta?.otelIgnoreMeter || mMeta?.otelIgnoreMeter,
+			ignoreSpan: cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan,
+			attrs: {
+				"moost.controller": controller ? (0, moost.getConstructor)(controller).name : undefined,
+				"moost.handler": methodName,
+				"moost.handler_description": mMeta?.description,
+				"moost.handler_label": mMeta?.label,
+				"moost.handler_id": mMeta?.id,
+				"moost.ignore": cMeta?.otelIgnoreSpan || mMeta?.otelIgnoreSpan,
+				"moost.route": getRoute(),
+				"moost.event_type": this.getEventType()
 			}
-			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];
+	}
+	hook(method, name, route) {
+		if (method === "WF_STEP") return;
+		if (method === "__SYSTEM__") return;
+		const { getSpan } = useOtelContext();
+		if (name === "Handler:not_found") {
+			const chm = this.getControllerHandlerMeta();
+			const span = getSpan();
+			if (span) {
+				const eventType = this.getEventType();
+				if (eventType === "HTTP") {
+					const req = this.getRequest();
+					span.updateName(`${req?.method || ""} ${req?.url}`);
+				}
+			}
+			this.startEventMetrics(chm.attrs, route);
+		} else if (name === "Controller:registered") {
+			const _route = (0, moost.useAsyncEventContext)().store("otel").get("route");
+			const chm = this.getControllerHandlerMeta();
+			if (!chm.ignoreMeter) this.startEventMetrics(chm.attrs, _route);
+			const span = getSpan();
+			if (span) {
+				span.setAttributes(chm.attrs);
+				if (chm.attrs["moost.event_type"] === "HTTP") span.updateName(`${this.getRequest()?.method || ""} ${_route || "<unresolved>"}`);
+				else span.updateName(`${chm.attrs["moost.event_type"]} ${_route || "<unresolved>"}`);
+			}
+		}
+		if (name !== "Controller:registered") (0, moost.useAsyncEventContext)().store("otel").set("route", route);
+	}
+	withSpan(span, cb, opts) {
+		return withSpan(span, cb, (_span, exception, result) => {
+			if (result instanceof Error) _span.recordException(result);
+			if (opts.withMetrics) {
+				const chm = this.getControllerHandlerMeta();
+				if (!chm.ignoreMeter) this.endEventMetrics(chm.attrs, result instanceof Error ? result : exception);
+			}
+			if (opts.endSpan) {
+				const customAttrs = (0, moost.useAsyncEventContext)().store("customSpanAttrs").value;
+				if (customAttrs) _span.setAttributes(customAttrs);
+				_span.end();
 			}
 		});
-	});
-	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;
+	startEventMetrics(a, route) {
+		(0, moost.useAsyncEventContext)().store("otel").set("startTime", Date.now());
 	}
-
-	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;
-	    }
+	endEventMetrics(a, error) {
+		const otelStore = (0, moost.useAsyncEventContext)().store("otel");
+		const route = otelStore.get("route");
+		const duration = Date.now() - (otelStore.get("startTime") || Date.now() - 1);
+		const customAttrs = (0, moost.useAsyncEventContext)().store("customMetricAttrs").value || {};
+		const attrs = {
+			...customAttrs,
+			route,
+			"moost.event_type": a["moost.event_type"],
+			"moost.is_error": error ? 1 : 0
+		};
+		if (a["moost.event_type"] === "HTTP") {
+			if (!attrs.route) attrs.route = this.getRequest()?.url || "";
+			attrs["http.status_code"] = this.getResponse()?._statusCode || 0;
+			attrs["moost.is_error"] = attrs["moost.is_error"] || attrs["http.status_code"] > 399 ? 1 : 0;
+		}
+		this.metrics.moostEventDuration.record(duration, attrs);
 	}
-
-	function escapeRegex(s) {
-	    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+	getRequest() {
+		return (0, moost.useAsyncEventContext)().store("event").get("req");
 	}
-
-	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');
+	getResponse() {
+		return (0, moost.useAsyncEventContext)().store("event").get("res");
 	}
-
-	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 + '' + '');
+	constructor(...args) {
+		super(...args), _define_property(this, "metrics", getMoostMetrics());
 	}
+};
 
-	exports.ProstoRouter = ProstoRouter;
-	exports.escapeRegex = escapeRegex;
-	exports.safeDecodeURI = safeDecodeURI;
-	exports.safeDecodeURIComponent = safeDecodeURIComponent; 
-} (router_cjs_prod));
+//#endregion
+//#region packages/otel/src/init.ts
+function enableOtelForMoost() {
+	(0, moost.replaceContextInjector)(new SpanInjector());
+}
 
+//#endregion
+//#region packages/otel/src/otel.mate.ts
 function getOtelMate() {
-    return getMoostMate();
+	return (0, moost.getMoostMate)();
 }
 
+//#endregion
+//#region packages/otel/src/otel.decorators.ts
 const mate = getOtelMate();
-const OtelIgnoreSpan = () => mate.decorate('otelIgnoreSpan', true);
-const OtelIgnoreMeter = () => mate.decorate('otelIgnoreMeter', true);
+const OtelIgnoreSpan = () => mate.decorate("otelIgnoreSpan", true);
+const OtelIgnoreMeter = () => mate.decorate("otelIgnoreMeter", true);
 
+//#endregion
+//#region packages/otel/src/processors/span-filter.ts
 function shouldSpanBeIgnored(span) {
-    return span.attributes['moost.ignore'] === true;
+	return span.attributes["moost.ignore"] === true;
 }
 
-class MoostBatchSpanProcessor extends sdkTraceBase.BatchSpanProcessor {
-    onEnd(span) {
-        if (shouldSpanBeIgnored(span)) {
-            return;
-        }
-        super.onEnd(span);
-    }
-}
-
-class MoostSimpleSpanProcessor extends sdkTraceBase.SimpleSpanProcessor {
-    onEnd(span) {
-        if (shouldSpanBeIgnored(span)) {
-            return;
-        }
-        super.onEnd(span);
-    }
-}
-
-exports.MoostBatchSpanProcessor = MoostBatchSpanProcessor;
-exports.MoostSimpleSpanProcessor = MoostSimpleSpanProcessor;
-exports.OtelIgnoreMeter = OtelIgnoreMeter;
-exports.OtelIgnoreSpan = OtelIgnoreSpan;
-exports.SpanInjector = SpanInjector;
-exports.enableOtelForMoost = enableOtelForMoost;
-exports.getOtelMate = getOtelMate;
-exports.shouldSpanBeIgnored = shouldSpanBeIgnored;
-exports.useOtelContext = useOtelContext;
-exports.useOtelPropagation = useOtelPropagation;
-exports.useSpan = useSpan;
-exports.useTrace = useTrace;
-exports.withSpan = withSpan;
+//#endregion
+//#region packages/otel/src/processors/batch-processor.ts
+var MoostBatchSpanProcessor = class extends __opentelemetry_sdk_trace_base.BatchSpanProcessor {
+	onEnd(span) {
+		if (shouldSpanBeIgnored(span)) return;
+		super.onEnd(span);
+	}
+};
+
+//#endregion
+//#region packages/otel/src/processors/simple-processor.ts
+var MoostSimpleSpanProcessor = class extends __opentelemetry_sdk_trace_base.SimpleSpanProcessor {
+	onEnd(span) {
+		if (shouldSpanBeIgnored(span)) return;
+		super.onEnd(span);
+	}
+};
+
+//#endregion
+exports.MoostBatchSpanProcessor = MoostBatchSpanProcessor
+exports.MoostSimpleSpanProcessor = MoostSimpleSpanProcessor
+exports.OtelIgnoreMeter = OtelIgnoreMeter
+exports.OtelIgnoreSpan = OtelIgnoreSpan
+exports.SpanInjector = SpanInjector
+exports.enableOtelForMoost = enableOtelForMoost
+exports.getOtelMate = getOtelMate
+exports.shouldSpanBeIgnored = shouldSpanBeIgnored
+exports.useOtelContext = useOtelContext
+exports.useOtelPropagation = useOtelPropagation
+exports.useSpan = useSpan
+exports.useTrace = useTrace
+exports.withSpan = withSpan