@routier/core 0.2.1 → 0.4.0

package/dist/capabilities/index.js

@@ -1,9 +1,385 @@
 var __webpack_modules__ = ({
-"./src/capabilities/Capability.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+581(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  Capability: () => (Capability)
+  vF: () => (logger)
 });
+/**
+ * Levelled logging, resolved once.
+ *
+ * Three things about the previous implementation drove this shape:
+ *
+ *  - **There was no way to turn logging off.** `globalThis.__ROUTIER_DEBUG__` was only ever
+ *    compared against `true`, so setting it to `false` did nothing — while
+ *    `docs/how-to/debug-logging.md` documented exactly that as the way to force logging off.
+ *    A documented switch that silently does nothing is worse than no switch.
+ *  - **`NODE_ENV === 'test'` enabled it.** Every Jest run therefore logged, because Jest always
+ *    sets `NODE_ENV=test`. Measured on the S7 stress scenario, which drives ~2,000 saves through
+ *    a plugin that logs three lines per query: 12.4s with logging, ~6s without. Test runners also
+ *    capture console output by snapshotting a stack trace per call, so the cost is far above what
+ *    writing to a terminal would suggest — and the output buries whatever the failure was.
+ *  - **It was all-or-nothing, and re-resolved per call.** An error could not be kept while debug
+ *    was dropped, and every one of the ~97 call sites re-read `globalThis` and `process.env`.
+ *
+ * Levels are compared numerically against a value cached at module load. Measured against a
+ * no-op console at 200k calls: an enabled call costs ~70ns, a call rejected by the gate ~3ns.
+ * Building the arguments the call site passes in accounts for ~0.2ns of that 3ns, which is why
+ * this keeps the ordinary `logger.debug(msg, payload)` signature instead of taking a thunk —
+ * a lazy API would recover 0.3% of an enabled call's cost and would have to change every call
+ * site to do it.
+ */ /** Ordered from most severe to most verbose. `silent` discards everything. */ const LOG_LEVELS = [
+    'silent',
+    'error',
+    'warn',
+    'info',
+    'debug'
+];
+/** Numeric rank, so a gate is one integer comparison. */ const RANK = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4
+};
+const isLogLevel = (value)=>typeof value === 'string' && LOG_LEVELS.includes(value);
+/**
+ * Resolves the configured level, in precedence order.
+ *
+ * Ordered most specific first: an explicit level beats a boolean flag, a boolean flag beats an
+ * environment variable, and an environment variable beats an inference from `NODE_ENV`. Anything
+ * unrecognised is ignored rather than treated as an error — a typo'd level should not take down
+ * an application, and `silent` is the safe direction to fall back to.
+ */ const resolveLevel = ()=>{
+    if (typeof globalThis !== 'undefined') {
+        const g = globalThis;
+        if (isLogLevel(g.__ROUTIER_LOG_LEVEL__)) {
+            return g.__ROUTIER_LOG_LEVEL__;
+        }
+        // Both directions honoured. `=== false` used to fall through to the NODE_ENV checks
+        // below and re-enable the logging it was asked to suppress.
+        if (g.__ROUTIER_DEBUG__ === true) return 'debug';
+        if (g.__ROUTIER_DEBUG__ === false) return 'silent';
+    }
+    // There is deliberately no `import.meta.env` branch, although the documentation used to
+    // promise one. It could never work: this package is bundled with rspack, which replaces
+    // `import.meta` with `undefined`, so the check would read the *library's* build-time
+    // environment rather than the application's — and referencing `import.meta` at all is a parse
+    // error under a CommonJS build target, which is how the test suite loads this file. Vite and
+    // similar apps set `__ROUTIER_LOG_LEVEL__` or `__ROUTIER_DEBUG__` from their own
+    // `import.meta.env`, which is what the docs now describe.
+    if (typeof process !== 'undefined' && process.env != null) {
+        if (isLogLevel(process.env.ROUTIER_LOG_LEVEL)) {
+            return process.env.ROUTIER_LOG_LEVEL;
+        }
+        const debug = process.env.DEBUG;
+        if (debug === 'routier' || debug === '*') return 'debug';
+        const env = "production"?.toLowerCase();
+        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere
+        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test
+        // needs the output.
+        if (env === 'dev' || env === 'development') return 'debug';
+    }
+    return 'silent';
+};
+let level = resolveLevel();
+let rank = RANK[level];
+/**
+ * Overrides the level for the rest of the process.
+ *
+ * The configuration above is read once, at import, which is what makes the gate cheap — but it
+ * also means an application that decides its verbosity after startup, or a test that wants to
+ * assert on output, has no way in. This is that way in.
+ */ const setLogLevel = (next)=>{
+    if (isLogLevel(next) === false) {
+        throw new Error(`Unknown log level "${next}". Expected one of: ${LOG_LEVELS.join(', ')}`);
+    }
+    level = next;
+    rank = RANK[next];
+};
+const getLogLevel = ()=>level;
+/** Re-reads the environment. For tests that change it after this module was imported. */ const resetLogLevel = ()=>{
+    level = resolveLevel();
+    rank = RANK[level];
+};
+/**
+ * Whether a message at this level would be emitted.
+ *
+ * For the rare call site whose *arguments* are expensive to build — a serialization, a deep
+ * clone, a join over a large collection. An ordinary payload object is not worth guarding; see
+ * the measurement in the header.
+ */ const isLogLevelEnabled = (at)=>rank >= RANK[at];
+const emit = (at, method, args)=>{
+    if (rank < RANK[at]) {
+        return;
+    }
+    // Resolved at call time rather than captured once: test harnesses and browser devtools both
+    // replace console methods after modules have loaded, and a captured reference would keep
+    // writing past the replacement.
+    console[method](...args);
+};
+const logger = {
+    /** General-purpose output. Carried at `info`, since `log` names a console method, not a level. */ log: (...args)=>emit('info', 'log', args),
+    info: (...args)=>emit('info', 'info', args),
+    warn: (...args)=>emit('warn', 'warn', args),
+    error: (...args)=>emit('error', 'error', args),
+    debug: (...args)=>emit('debug', 'debug', args),
+    /** Diagnostic tabular output; verbose by nature, so it sits at `debug`. */ table: (...args)=>emit('debug', 'table', args)
+};
+
+
+},
+615(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  Zm: () => (stringifyObject)
+});
+const hash = (value, seed = 0)=>{
+    // From Stack Overflow
+    // https://stackoverflow.com/a/52171480/3329760
+    let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
+    for(let i = 0, ch; i < value.length; i++){
+        ch = value.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+    h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+    h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+    h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+};
+/**
+ * Fast string hash optimized for comparisons.
+ * Uses djb2 algorithm - very fast and good distribution for short to medium strings.
+ * Same input always produces same output (deterministic).
+ * 
+ * @param value - The string to hash
+ * @param seed - Optional seed value (default: 5381)
+ * @returns A positive 32-bit integer hash value
+ * 
+ * @example
+ * ```ts
+ * fastHash("test") === fastHash("test") // true
+ * fastHash("test") !== fastHash("test2") // true
+ * ```
+ */ const fastHash = (value, seed = 5381)=>{
+    let hash = seed;
+    for(let i = 0; i < value.length; i++){
+        hash = (hash << 5) + hash + value.charCodeAt(i);
+    }
+    return hash >>> 0; // Convert to unsigned 32-bit integer
+};
+/**
+ * Converts any value to a readable string representation.
+ * Handles primitives, objects, arrays, classes, dates, errors, and functions.
+ * Supports depth limiting to prevent infinite recursion on circular references.
+ * 
+ * @param obj - The value to stringify
+ * @param maxDepth - Maximum depth for nested objects (default: 3)
+ * @param currentDepth - Current recursion depth (default: 0)
+ * @returns String representation of the value
+ * 
+ * @example
+ * ```ts
+ * stringifyObject({ name: "test", count: 5 }) // '{ name: "test", count: 5 }'
+ * stringifyObject([1, 2, 3]) // '[1, 2, 3]'
+ * stringifyObject(new Date()) // 'Date(2024-01-01T00:00:00.000Z)'
+ * ```
+ */ function stringifyObject(obj, maxDepth = 3, currentDepth = 0) {
+    if (obj === null) return 'null';
+    if (obj === undefined) return 'undefined';
+    const type = typeof obj;
+    switch(type){
+        case 'string':
+            return `"${obj}"`;
+        case 'number':
+        case 'boolean':
+            return String(obj);
+        case 'function':
+            return `[Function: ${getFunctionName(obj)}]`;
+        case 'object':
+            if (currentDepth >= maxDepth) {
+                return '[Max Depth Reached]';
+            }
+            return stringifyObjectValue(obj, maxDepth, currentDepth);
+        default:
+            return `[${type}]`;
+    }
+}
+function getFunctionName(fn) {
+    const name = fn.name;
+    return name || 'anonymous';
+}
+function getObjectProperties(obj) {
+    const properties = {};
+    for(const key in obj){
+        if (obj.hasOwnProperty(key)) {
+            properties[key] = obj[key];
+        }
+    }
+    return properties;
+}
+function stringifyObjectValue(obj, maxDepth, currentDepth) {
+    if (obj === null) return 'null';
+    if (obj instanceof Date) {
+        return `Date(${obj.toISOString()})`;
+    }
+    if (obj instanceof Error) {
+        return `Error(${obj.message})`;
+    }
+    if (obj instanceof RegExp) {
+        return obj.toString();
+    }
+    if (Array.isArray(obj)) {
+        return stringifyArray(obj, maxDepth, currentDepth);
+    }
+    if (obj.constructor && obj.constructor.name !== 'Object') {
+        return stringifyClassInstance(obj, maxDepth, currentDepth);
+    }
+    return stringifyPlainObject(obj, maxDepth, currentDepth);
+}
+function stringifyArray(arr, maxDepth, currentDepth) {
+    if (arr.length === 0) return '[]';
+    const items = arr.slice(0, 5).map((item)=>stringifyObject(item, maxDepth, currentDepth + 1));
+    const suffix = arr.length > 5 ? `... (+${arr.length - 5} more)` : '';
+    return `[${items.join(', ')}${suffix}]`;
+}
+function stringifyClassInstance(obj, maxDepth, currentDepth) {
+    const className = obj.constructor.name;
+    const properties = getObjectProperties(obj);
+    if (Object.keys(properties).length === 0) {
+        return `${className} {}`;
+    }
+    const props = Object.entries(properties).slice(0, 5).map(([key, value])=>{
+        const isPrimitive = value === null || value === undefined || typeof value !== 'object' && typeof value !== 'function';
+        const depth = isPrimitive ? currentDepth : currentDepth + 1;
+        return `${key}: ${stringifyObject(value, maxDepth, depth)}`;
+    });
+    const suffix = Object.keys(properties).length > 5 ? `... (+${Object.keys(properties).length - 5} more)` : '';
+    return `${className} { ${props.join(', ')}${suffix} }`;
+}
+function stringifyPlainObject(obj, maxDepth, currentDepth) {
+    const properties = getObjectProperties(obj);
+    if (Object.keys(properties).length === 0) {
+        return '{}';
+    }
+    const props = Object.entries(properties).slice(0, 5).map(([key, value])=>{
+        const isPrimitive = value === null || value === undefined || typeof value !== 'object' && typeof value !== 'function';
+        const depth = isPrimitive ? currentDepth : currentDepth + 1;
+        return `${key}: ${stringifyObject(value, maxDepth, depth)}`;
+    });
+    const suffix = Object.keys(properties).length > 5 ? `... (+${Object.keys(properties).length - 5} more)` : '';
+    return `{ ${props.join(', ')}${suffix} }`;
+}
+
+
+},
+618(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  u: () => (uuid)
+});
+const uuid = (length = 16)=>{
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charLength = chars.length;
+    let result = '';
+    for(let i = 0; i < length; i++){
+        result += chars[Math.random() * charLength | 0];
+    }
+    return result;
+};
+const HEX_CHARS = '0123456789abcdef';
+const UUID_TEMPLATE = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+const hasCrypto = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function';
+const hasRandomUUID = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function';
+const uuidv4 = ()=>{
+    if (hasRandomUUID) {
+        return crypto.randomUUID();
+    }
+    return uuidv4Fallback();
+};
+const uuidv4Fallback = ()=>{
+    let randomBytes = null;
+    if (hasCrypto) {
+        randomBytes = crypto.getRandomValues(new Uint8Array(16));
+    }
+    let byteIndex = 0;
+    let uuid = '';
+    for(let i = 0; i < UUID_TEMPLATE.length; i++){
+        const c = UUID_TEMPLATE[i];
+        if (c === '-') {
+            uuid += '-';
+            continue;
+        }
+        let r;
+        if (hasCrypto && randomBytes) {
+            // Each byte gives two hex digits (nibbles)
+            r = i % 2 === 0 ? randomBytes[byteIndex] >> 4 : randomBytes[byteIndex++] & 0x0f;
+        } else {
+            r = Math.floor(Math.random() * 16);
+        }
+        if (c === 'x') {
+            uuid += HEX_CHARS[r];
+        } else if (c === 'y') {
+            // Variant bits: 8, 9, A, or B
+            uuid += HEX_CHARS[r & 0x3 | 0x8];
+        } else if (c === '4') {
+            uuid += '4';
+        }
+    }
+    return uuid;
+};
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  nS: () => (/* reexport */ Capability),
+  VP: () => (/* reexport */ PerformanceCapability),
+  XO: () => (/* reexport */ TracingCapability)
+});
+
+;// CONCATENATED MODULE: ./src/capabilities/Capability.ts
 class Capability {
     excludedNames = new Set([
         "Array",
@@ -20,6 +396,7 @@ class Capability {
         "SchemaDefault",
         "SchemaDeserialize",
         "SchemaDistinct",
+        "SchemaSearchable",
         "SchemaFrom",
         "SchemaIdentity",
         "SchemaIndex",
@@ -38,10 +415,7 @@ class Capability {
         return typeof obj === "object" && obj !== null;
     }
     isCallableMethod(descriptor, key) {
-        return (descriptor?.value &&
-            typeof descriptor.value === 'function' &&
-            key !== 'constructor' &&
-            key !== 'undefined');
+        return descriptor?.value && typeof descriptor.value === 'function' && key !== 'constructor' && key !== 'undefined';
     }
     canExplore(descriptor) {
         if (typeof descriptor.value !== "object") {
@@ -64,8 +438,11 @@ class Capability {
     }
     getPath(info, propertyName) {
         let parent = info.parent;
-        const path = [info.propertyName, propertyName];
-        while (parent != null) {
+        const path = [
+            info.propertyName,
+            propertyName
+        ];
+        while(parent != null){
             path.unshift(parent.propertyName);
             parent = parent.parent;
         }
@@ -75,9 +452,14 @@ class Capability {
         if (!this.isValidObject(instance)) {
             return;
         }
-        const explore = [{ instance, propertyName: this.getName(instance) }];
+        const explore = [
+            {
+                instance,
+                propertyName: this.getName(instance)
+            }
+        ];
         const visited = new Set();
-        for (let i = 0; i < explore.length; i++) {
+        for(let i = 0; i < explore.length; i++){
             const info = explore[i];
             const item = info.instance;
             if (visited.has(item)) {
@@ -85,9 +467,9 @@ class Capability {
             }
             const allKeys = [
                 ...Object.getOwnPropertyNames(item),
-                ...Object.getOwnPropertySymbols(item),
+                ...Object.getOwnPropertySymbols(item)
             ];
-            for (const key of allKeys) {
+            for (const key of allKeys){
                 const descriptor = Object.getOwnPropertyDescriptor(item, key);
                 const isCallable = this.isCallableMethod(descriptor, key);
                 onDiscover(info, {
@@ -98,53 +480,166 @@ class Capability {
                     continue;
                 }
                 const path = this.getPath(info, key);
-                explore.push({ instance: descriptor.value, parent: info, propertyName: key, path });
+                explore.push({
+                    instance: descriptor.value,
+                    parent: info,
+                    propertyName: key,
+                    path
+                });
             }
             visited.add(item);
         }
     }
 }
 
-
-},
-"./src/capabilities/PerformanceCapability.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  PerformanceCapability: () => (PerformanceCapability)
-});
-/* import */ var _utilities__rspack_import_4 = __webpack_require__("./src/utilities/strings.ts");
-/* import */ var _Capability__rspack_import_0 = __webpack_require__("./src/capabilities/Capability.ts");
-/* import */ var _performance_PerformanceTracker__rspack_import_2 = __webpack_require__("./src/capabilities/performance/PerformanceTracker.ts");
-/* import */ var _tracing_CallTraceManager__rspack_import_1 = __webpack_require__("./src/capabilities/tracing/CallTraceManager.ts");
-/* import */ var _utilities__rspack_import_3 = __webpack_require__("./src/utilities/logger.ts");
-
-
-
-
-
-class PerformanceCapability extends _Capability__rspack_import_0.Capability {
-    callTraceManager;
-    performanceTracker;
-    filter;
-    childDurations = new Map();
-    constructor(options) {
-        super();
-        this.filter = options?.filter ?? (() => true);
-        this.callTraceManager = new _tracing_CallTraceManager__rspack_import_1.CallTraceManager();
-        this.performanceTracker = new _performance_PerformanceTracker__rspack_import_2.PerformanceTracker();
-    }
-    apply(instance) {
-        this.explore(instance, (meta, info) => {
-            if (info.isCallable) {
-                const originalMethod = meta.instance[info.name].bind(meta.instance);
-                meta.instance[info.name] = (...args) => {
-                    const path = `${meta.path}.${String(info.name)}()`;
-                    if (this.filter(path, info, meta) === false) {
-                        return originalMethod(...args);
-                    }
-                    const isNewOperation = this.callTraceManager.isNewOperation();
-                    let operationId;
-                    let callTrace;
+// EXTERNAL MODULE: ./src/utilities/strings.ts
+var strings = __webpack_require__(615);
+;// CONCATENATED MODULE: ./src/capabilities/performance/PerformanceTracker.ts
+class PerformanceTracker {
+    methodTimings = new Map();
+    operationStartTimes = new Map();
+    startMethodTiming(operationId, methodPath) {
+        const startTime = performance.now();
+        const key = `${operationId}:${methodPath}`;
+        // Track operation start time for delta calculations
+        if (!this.operationStartTimes.has(operationId)) {
+            this.operationStartTimes.set(operationId, startTime);
+        }
+        this.methodTimings.set(key, {
+            startTime
+        });
+        return startTime;
+    }
+    recordNextMethodStart(operationId, methodPath) {
+        const key = `${operationId}:${methodPath}`;
+        const timing = this.methodTimings.get(key);
+        if (timing) {
+            timing.nextMethodStartTime = performance.now();
+        }
+    }
+    endMethodTiming(operationId, methodPath) {
+        const endTime = performance.now();
+        const key = `${operationId}:${methodPath}`;
+        const timing = this.methodTimings.get(key);
+        if (!timing) {
+            return {
+                startTime: endTime
+            };
+        }
+        const duration = endTime - timing.startTime;
+        const timeToNextCall = timing.nextMethodStartTime ? timing.nextMethodStartTime - timing.startTime : undefined;
+        // Clean up
+        this.methodTimings.delete(key);
+        return {
+            startTime: timing.startTime,
+            endTime,
+            duration,
+            nextMethodStartTime: timing.nextMethodStartTime,
+            timeToNextCall
+        };
+    }
+    formatDuration(milliseconds) {
+        if (milliseconds < 1) {
+            return `${(milliseconds * 1000).toFixed(1)}μs`;
+        } else if (milliseconds < 1000) {
+            return `${milliseconds.toFixed(2)}ms`;
+        } else {
+            return `${(milliseconds / 1000).toFixed(2)}s`;
+        }
+    }
+    getDeltaFromOperationStart(operationId, currentTime) {
+        const operationStartTime = this.operationStartTimes.get(operationId);
+        return operationStartTime ? currentTime - operationStartTime : 0;
+    }
+    cleanupOperation(operationId) {
+        this.operationStartTimes.delete(operationId);
+    }
+}
+
+// EXTERNAL MODULE: ./src/utilities/uuid.ts
+var uuid = __webpack_require__(618);
+;// CONCATENATED MODULE: ./src/capabilities/tracing/CallTraceManager.ts
+
+class CallTraceManager {
+    activeOperationId = null;
+    activeCallStack = [];
+    startNewOperation() {
+        const operationId = (0,uuid/* .uuid */.u)(8);
+        this.activeOperationId = operationId;
+        this.activeCallStack = [];
+        return operationId;
+    }
+    isNewOperation() {
+        return this.activeOperationId === null;
+    }
+    getActiveOperationId() {
+        if (!this.activeOperationId) {
+            throw new Error('No active operation context');
+        }
+        return this.activeOperationId;
+    }
+    addMethodToTrace(methodPath) {
+        if (this.isNewOperation()) {
+            this.activeCallStack = [
+                methodPath
+            ];
+        } else {
+            this.activeCallStack.push(methodPath);
+        }
+        return [
+            ...this.activeCallStack
+        ];
+    }
+    removeMethodFromTrace() {
+        if (!this.isNewOperation()) {
+            this.activeCallStack.pop();
+        }
+    }
+    endOperation() {
+        this.activeOperationId = null;
+        this.activeCallStack = [];
+    }
+    formatMethodPaths(methodPaths) {
+        return methodPaths.map((path)=>path.replace(/ → /g, '.'));
+    }
+    getCurrentTrace() {
+        return [
+            ...this.activeCallStack
+        ];
+    }
+}
+
+// EXTERNAL MODULE: ./src/utilities/logger.ts
+var logger = __webpack_require__(581);
+;// CONCATENATED MODULE: ./src/capabilities/PerformanceCapability.ts
+
+
+
+
+
+class PerformanceCapability extends Capability {
+    callTraceManager;
+    performanceTracker;
+    filter;
+    childDurations = new Map();
+    constructor(options){
+        super();
+        this.filter = options?.filter ?? (()=>true);
+        this.callTraceManager = new CallTraceManager();
+        this.performanceTracker = new PerformanceTracker();
+    }
+    apply(instance) {
+        this.explore(instance, (meta, info)=>{
+            if (info.isCallable) {
+                const originalMethod = meta.instance[info.name].bind(meta.instance);
+                meta.instance[info.name] = (...args)=>{
+                    const path = `${meta.path}.${String(info.name)}()`;
+                    if (this.filter(path, info, meta) === false) {
+                        return originalMethod(...args);
+                    }
+                    const isNewOperation = this.callTraceManager.isNewOperation();
+                    let operationId;
+                    let callTrace;
                     let depth;
                     if (isNewOperation) {
                         operationId = this.callTraceManager.startNewOperation();
@@ -153,14 +648,13 @@ class PerformanceCapability extends _Capability__rspack_import_0.Capability {
                         depth = callTrace.length - 1;
                         const formattedCallTrace = this.callTraceManager.formatMethodPaths(callTrace);
                         this.performanceTracker.startMethodTiming(operationId, path);
-                        _utilities__rspack_import_3.logger.log(`\n${'═'.repeat(60)}`);
-                        _utilities__rspack_import_3.logger.log(`▶ ORIGIN [${operationId}] ${path}`);
+                        logger/* .logger.log */.vF.log(`\n${'═'.repeat(60)}`);
+                        logger/* .logger.log */.vF.log(`▶ ORIGIN [${operationId}] ${path}`);
                         if (args.length > 0) {
-                            _utilities__rspack_import_3.logger.log(`  Args:`, (0,_utilities__rspack_import_4.stringifyObject)(args, 4, 0));
+                            logger/* .logger.log */.vF.log(`  Args:`, (0,strings/* .stringifyObject */.Zm)(args, 4, 0));
                         }
-                        _utilities__rspack_import_3.logger.log(`  Call Stack: ${formattedCallTrace.join(' → ')}`);
-                    }
-                    else {
+                        logger/* .logger.log */.vF.log(`  Call Stack: ${formattedCallTrace.join(' → ')}`);
+                    } else {
                         operationId = this.callTraceManager.getActiveOperationId();
                         callTrace = this.callTraceManager.addMethodToTrace(path);
                         depth = callTrace.length - 1;
@@ -169,47 +663,45 @@ class PerformanceCapability extends _Capability__rspack_import_0.Capability {
                         const childMethodKey = `${operationId}:${path}`;
                         this.childDurations.set(childMethodKey, []);
                         this.performanceTracker.startMethodTiming(operationId, path);
-                        _utilities__rspack_import_3.logger.log(`${indent}└─ CHILD [${operationId}] ${path}`);
+                        logger/* .logger.log */.vF.log(`${indent}└─ CHILD [${operationId}] ${path}`);
                         if (args.length > 0) {
-                            _utilities__rspack_import_3.logger.log(`${indent}   Args:`, (0,_utilities__rspack_import_4.stringifyObject)(args, 4, 0));
+                            logger/* .logger.log */.vF.log(`${indent}   Args:`, (0,strings/* .stringifyObject */.Zm)(args, 4, 0));
                         }
                     }
                     try {
                         return originalMethod(...args);
-                    }
-                    finally {
+                    } finally{
                         const metrics = this.performanceTracker.endMethodTiming(operationId, path);
                         const duration = metrics.duration ?? 0;
                         const formattedDuration = this.performanceTracker.formatDuration(duration);
                         if (isNewOperation) {
                             const childDurations = this.childDurations.get(operationId) ?? [];
-                            const totalChildTime = childDurations.reduce((sum, d) => sum + d, 0);
+                            const totalChildTime = childDurations.reduce((sum, d)=>sum + d, 0);
                             const formattedTotalChildTime = this.performanceTracker.formatDuration(totalChildTime);
                             const overhead = duration - totalChildTime;
                             const formattedOverhead = this.performanceTracker.formatDuration(Math.max(0, overhead));
-                            _utilities__rspack_import_3.logger.log(`\n${'═'.repeat(60)}`);
-                            _utilities__rspack_import_3.logger.log(`◀ COMPLETE [${operationId}] ${path}`);
-                            _utilities__rspack_import_3.logger.log(`  Total Duration: ${formattedDuration}`);
+                            logger/* .logger.log */.vF.log(`\n${'═'.repeat(60)}`);
+                            logger/* .logger.log */.vF.log(`◀ COMPLETE [${operationId}] ${path}`);
+                            logger/* .logger.log */.vF.log(`  Total Duration: ${formattedDuration}`);
                             if (childDurations.length > 0) {
-                                _utilities__rspack_import_3.logger.log(`  Children Duration: ${formattedTotalChildTime} (${childDurations.length} calls)`);
-                                _utilities__rspack_import_3.logger.log(`  Overhead: ${formattedOverhead}`);
+                                logger/* .logger.log */.vF.log(`  Children Duration: ${formattedTotalChildTime} (${childDurations.length} calls)`);
+                                logger/* .logger.log */.vF.log(`  Overhead: ${formattedOverhead}`);
                             }
-                            _utilities__rspack_import_3.logger.log(`${'═'.repeat(60)}\n`);
+                            logger/* .logger.log */.vF.log(`${'═'.repeat(60)}\n`);
                             this.childDurations.delete(operationId);
                             this.performanceTracker.cleanupOperation(operationId);
                             this.callTraceManager.endOperation();
-                        }
-                        else {
+                        } else {
                             const indent = '  '.repeat(Math.min(depth, 4));
                             const childMethodKey = `${operationId}:${path}`;
                             const childDurations = this.childDurations.get(childMethodKey) ?? [];
-                            const totalChildTime = childDurations.reduce((sum, d) => sum + d, 0);
+                            const totalChildTime = childDurations.reduce((sum, d)=>sum + d, 0);
                             const formattedTotalChildTime = this.performanceTracker.formatDuration(totalChildTime);
                             const overhead = duration - totalChildTime;
                             const formattedOverhead = this.performanceTracker.formatDuration(Math.max(0, overhead));
-                            _utilities__rspack_import_3.logger.log(`${indent}   ✓ ${formattedDuration}`);
+                            logger/* .logger.log */.vF.log(`${indent}   ✓ ${formattedDuration}`);
                             if (childDurations.length > 0) {
-                                _utilities__rspack_import_3.logger.log(`${indent}     Children: ${formattedTotalChildTime} (${childDurations.length} calls), Overhead: ${formattedOverhead}`);
+                                logger/* .logger.log */.vF.log(`${indent}     Children: ${formattedTotalChildTime} (${childDurations.length} calls), Overhead: ${formattedOverhead}`);
                             }
                             // Clean up child method tracking
                             this.childDurations.delete(childMethodKey);
@@ -226,8 +718,7 @@ class PerformanceCapability extends _Capability__rspack_import_0.Capability {
                                     if (rootChildDurations) {
                                         rootChildDurations.push(duration);
                                     }
-                                }
-                                else {
+                                } else {
                                     // Nested child - add to parent method's children list
                                     const parentMethodKey = `${operationId}:${parentPath}`;
                                     const parentChildDurations = this.childDurations.get(parentMethodKey);
@@ -245,32 +736,23 @@ class PerformanceCapability extends _Capability__rspack_import_0.Capability {
     }
 }
 
-
-},
-"./src/capabilities/TracingCapability.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  TracingCapability: () => (TracingCapability)
-});
-/* import */ var _Capability__rspack_import_0 = __webpack_require__("./src/capabilities/Capability.ts");
-/* import */ var _tracing_CallTraceManager__rspack_import_1 = __webpack_require__("./src/capabilities/tracing/CallTraceManager.ts");
-/* import */ var _utilities_strings__rspack_import_2 = __webpack_require__("./src/utilities/strings.ts");
+;// CONCATENATED MODULE: ./src/capabilities/TracingCapability.ts
 
 
 
-class TracingCapability extends _Capability__rspack_import_0.Capability {
+class TracingCapability extends Capability {
     callTraceManager;
     filter;
-    constructor(options) {
+    constructor(options){
         super();
-        this.filter = options?.filter ?? (() => true);
-        this.callTraceManager = new _tracing_CallTraceManager__rspack_import_1.CallTraceManager();
+        this.filter = options?.filter ?? (()=>true);
+        this.callTraceManager = new CallTraceManager();
     }
     apply(instance) {
-        this.explore(instance, (meta, info) => {
+        this.explore(instance, (meta, info)=>{
             if (info.isCallable) {
                 const originalMethod = meta.instance[info.name].bind(meta.instance);
-                meta.instance[info.name] = (...args) => {
+                meta.instance[info.name] = (...args)=>{
                     const path = `${meta.path}.${String(info.name)}()`;
                     if (this.filter(path, info, meta) === false) {
                         return originalMethod(...args);
@@ -284,23 +766,21 @@ class TracingCapability extends _Capability__rspack_import_0.Capability {
                         console.log(`\n${'═'.repeat(60)}`);
                         console.log(`▶ ORIGIN [${operationId}] ${path}`);
                         if (args.length > 0) {
-                            console.log(`  Args:`, (0,_utilities_strings__rspack_import_2.stringifyObject)(args, 4, 0));
+                            console.log(`  Args:`, (0,strings/* .stringifyObject */.Zm)(args, 4, 0));
                         }
                         console.log(`  Call Stack: ${formattedCallTrace.join(' → ')}`);
-                    }
-                    else {
+                    } else {
                         operationId = this.callTraceManager.getActiveOperationId();
                         const callTrace = this.callTraceManager.addMethodToTrace(path);
                         const indent = '  '.repeat(Math.min(callTrace.length - 1, 4));
                         console.log(`${indent}└─ CHILD [${operationId}] ${path}`);
                         if (args.length > 0) {
-                            console.log(`${indent}   Args:`, (0,_utilities_strings__rspack_import_2.stringifyObject)(args, 4, 0));
+                            console.log(`${indent}   Args:`, (0,strings/* .stringifyObject */.Zm)(args, 4, 0));
                         }
                     }
                     try {
                         return originalMethod(...args);
-                    }
-                    finally {
+                    } finally{
                         this.callTraceManager.removeMethodFromTrace();
                         if (isNewOperation) {
                             this.callTraceManager.endOperation();
@@ -312,461 +792,7 @@ class TracingCapability extends _Capability__rspack_import_0.Capability {
     }
 }
 
-
-},
-"./src/capabilities/performance/PerformanceTracker.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  PerformanceTracker: () => (PerformanceTracker)
-});
-class PerformanceTracker {
-    methodTimings = new Map();
-    operationStartTimes = new Map();
-    startMethodTiming(operationId, methodPath) {
-        const startTime = performance.now();
-        const key = `${operationId}:${methodPath}`;
-        // Track operation start time for delta calculations
-        if (!this.operationStartTimes.has(operationId)) {
-            this.operationStartTimes.set(operationId, startTime);
-        }
-        this.methodTimings.set(key, { startTime });
-        return startTime;
-    }
-    recordNextMethodStart(operationId, methodPath) {
-        const key = `${operationId}:${methodPath}`;
-        const timing = this.methodTimings.get(key);
-        if (timing) {
-            timing.nextMethodStartTime = performance.now();
-        }
-    }
-    endMethodTiming(operationId, methodPath) {
-        const endTime = performance.now();
-        const key = `${operationId}:${methodPath}`;
-        const timing = this.methodTimings.get(key);
-        if (!timing) {
-            return { startTime: endTime };
-        }
-        const duration = endTime - timing.startTime;
-        const timeToNextCall = timing.nextMethodStartTime ?
-            timing.nextMethodStartTime - timing.startTime : undefined;
-        // Clean up
-        this.methodTimings.delete(key);
-        return {
-            startTime: timing.startTime,
-            endTime,
-            duration,
-            nextMethodStartTime: timing.nextMethodStartTime,
-            timeToNextCall
-        };
-    }
-    formatDuration(milliseconds) {
-        if (milliseconds < 1) {
-            return `${(milliseconds * 1000).toFixed(1)}μs`;
-        }
-        else if (milliseconds < 1000) {
-            return `${milliseconds.toFixed(2)}ms`;
-        }
-        else {
-            return `${(milliseconds / 1000).toFixed(2)}s`;
-        }
-    }
-    getDeltaFromOperationStart(operationId, currentTime) {
-        const operationStartTime = this.operationStartTimes.get(operationId);
-        return operationStartTime ? currentTime - operationStartTime : 0;
-    }
-    cleanupOperation(operationId) {
-        this.operationStartTimes.delete(operationId);
-    }
-}
-
-
-},
-"./src/capabilities/tracing/CallTraceManager.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  CallTraceManager: () => (CallTraceManager)
-});
-/* import */ var _utilities__rspack_import_0 = __webpack_require__("./src/utilities/uuid.ts");
-
-class CallTraceManager {
-    activeOperationId = null;
-    activeCallStack = [];
-    startNewOperation() {
-        const operationId = (0,_utilities__rspack_import_0.uuid)(8);
-        this.activeOperationId = operationId;
-        this.activeCallStack = [];
-        return operationId;
-    }
-    isNewOperation() {
-        return this.activeOperationId === null;
-    }
-    getActiveOperationId() {
-        if (!this.activeOperationId) {
-            throw new Error('No active operation context');
-        }
-        return this.activeOperationId;
-    }
-    addMethodToTrace(methodPath) {
-        if (this.isNewOperation()) {
-            this.activeCallStack = [methodPath];
-        }
-        else {
-            this.activeCallStack.push(methodPath);
-        }
-        return [...this.activeCallStack];
-    }
-    removeMethodFromTrace() {
-        if (!this.isNewOperation()) {
-            this.activeCallStack.pop();
-        }
-    }
-    endOperation() {
-        this.activeOperationId = null;
-        this.activeCallStack = [];
-    }
-    formatMethodPaths(methodPaths) {
-        return methodPaths.map(path => path.replace(/ → /g, '.'));
-    }
-    getCurrentTrace() {
-        return [...this.activeCallStack];
-    }
-}
-
-
-},
-"./src/utilities/logger.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  logger: () => (logger)
-});
-/**
- * Enable logging by setting `globalThis.__ROUTIER_DEBUG__ = true` before any routier code runs.
- */
-const shouldLog = () => {
-    if (typeof globalThis !== 'undefined') {
-        const g = globalThis;
-        if (g.__ROUTIER_DEBUG__ === true)
-            return true;
-    }
-    if (typeof process !== 'undefined' && process.env != null) {
-        const debug = process.env.DEBUG;
-        if (debug === 'routier' || debug === '*')
-            return true;
-        const env = "development"?.toLowerCase();
-        if (env === 'dev' || env === 'development' || env === 'test')
-            return true;
-    }
-    return false;
-};
-const tryLog = (type, ...args) => {
-    if (shouldLog()) {
-        console[type](...args);
-    }
-};
-const logger = {
-    log: (...args) => {
-        tryLog("log", ...args);
-    },
-    info: (...args) => {
-        tryLog("info", ...args);
-    },
-    warn: (...args) => {
-        tryLog("warn", ...args);
-    },
-    error: (...args) => {
-        tryLog("error", ...args);
-    },
-    debug: (...args) => {
-        tryLog("debug", ...args);
-    },
-    table: (...args) => {
-        tryLog("table", ...args);
-    },
-};
-
-
-},
-"./src/utilities/strings.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  fastHash: () => (fastHash),
-  hash: () => (hash),
-  stringifyObject: () => (stringifyObject)
-});
-const hash = (value, seed = 0) => {
-    // From Stack Overflow
-    // https://stackoverflow.com/a/52171480/3329760
-    let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
-    for (let i = 0, ch; i < value.length; i++) {
-        ch = value.charCodeAt(i);
-        h1 = Math.imul(h1 ^ ch, 2654435761);
-        h2 = Math.imul(h2 ^ ch, 1597334677);
-    }
-    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
-    h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
-    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
-    h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
-    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
-};
-/**
- * Fast string hash optimized for comparisons.
- * Uses djb2 algorithm - very fast and good distribution for short to medium strings.
- * Same input always produces same output (deterministic).
- *
- * @param value - The string to hash
- * @param seed - Optional seed value (default: 5381)
- * @returns A positive 32-bit integer hash value
- *
- * @example
- * ```ts
- * fastHash("test") === fastHash("test") // true
- * fastHash("test") !== fastHash("test2") // true
- * ```
- */
-const fastHash = (value, seed = 5381) => {
-    let hash = seed;
-    for (let i = 0; i < value.length; i++) {
-        hash = ((hash << 5) + hash) + value.charCodeAt(i);
-    }
-    return hash >>> 0; // Convert to unsigned 32-bit integer
-};
-/**
- * Converts any value to a readable string representation.
- * Handles primitives, objects, arrays, classes, dates, errors, and functions.
- * Supports depth limiting to prevent infinite recursion on circular references.
- *
- * @param obj - The value to stringify
- * @param maxDepth - Maximum depth for nested objects (default: 3)
- * @param currentDepth - Current recursion depth (default: 0)
- * @returns String representation of the value
- *
- * @example
- * ```ts
- * stringifyObject({ name: "test", count: 5 }) // '{ name: "test", count: 5 }'
- * stringifyObject([1, 2, 3]) // '[1, 2, 3]'
- * stringifyObject(new Date()) // 'Date(2024-01-01T00:00:00.000Z)'
- * ```
- */
-function stringifyObject(obj, maxDepth = 3, currentDepth = 0) {
-    if (obj === null)
-        return 'null';
-    if (obj === undefined)
-        return 'undefined';
-    const type = typeof obj;
-    switch (type) {
-        case 'string':
-            return `"${obj}"`;
-        case 'number':
-        case 'boolean':
-            return String(obj);
-        case 'function':
-            return `[Function: ${getFunctionName(obj)}]`;
-        case 'object':
-            if (currentDepth >= maxDepth) {
-                return '[Max Depth Reached]';
-            }
-            return stringifyObjectValue(obj, maxDepth, currentDepth);
-        default:
-            return `[${type}]`;
-    }
-}
-function getFunctionName(fn) {
-    const name = fn.name;
-    return name || 'anonymous';
-}
-function getObjectProperties(obj) {
-    const properties = {};
-    for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            properties[key] = obj[key];
-        }
-    }
-    return properties;
-}
-function stringifyObjectValue(obj, maxDepth, currentDepth) {
-    if (obj === null)
-        return 'null';
-    if (obj instanceof Date) {
-        return `Date(${obj.toISOString()})`;
-    }
-    if (obj instanceof Error) {
-        return `Error(${obj.message})`;
-    }
-    if (obj instanceof RegExp) {
-        return obj.toString();
-    }
-    if (Array.isArray(obj)) {
-        return stringifyArray(obj, maxDepth, currentDepth);
-    }
-    if (obj.constructor && obj.constructor.name !== 'Object') {
-        return stringifyClassInstance(obj, maxDepth, currentDepth);
-    }
-    return stringifyPlainObject(obj, maxDepth, currentDepth);
-}
-function stringifyArray(arr, maxDepth, currentDepth) {
-    if (arr.length === 0)
-        return '[]';
-    const items = arr.slice(0, 5).map(item => stringifyObject(item, maxDepth, currentDepth + 1));
-    const suffix = arr.length > 5 ? `... (+${arr.length - 5} more)` : '';
-    return `[${items.join(', ')}${suffix}]`;
-}
-function stringifyClassInstance(obj, maxDepth, currentDepth) {
-    const className = obj.constructor.name;
-    const properties = getObjectProperties(obj);
-    if (Object.keys(properties).length === 0) {
-        return `${className} {}`;
-    }
-    const props = Object.entries(properties)
-        .slice(0, 5)
-        .map(([key, value]) => {
-        const isPrimitive = value === null || value === undefined ||
-            (typeof value !== 'object' && typeof value !== 'function');
-        const depth = isPrimitive ? currentDepth : currentDepth + 1;
-        return `${key}: ${stringifyObject(value, maxDepth, depth)}`;
-    });
-    const suffix = Object.keys(properties).length > 5 ?
-        `... (+${Object.keys(properties).length - 5} more)` : '';
-    return `${className} { ${props.join(', ')}${suffix} }`;
-}
-function stringifyPlainObject(obj, maxDepth, currentDepth) {
-    const properties = getObjectProperties(obj);
-    if (Object.keys(properties).length === 0) {
-        return '{}';
-    }
-    const props = Object.entries(properties)
-        .slice(0, 5)
-        .map(([key, value]) => {
-        const isPrimitive = value === null || value === undefined ||
-            (typeof value !== 'object' && typeof value !== 'function');
-        const depth = isPrimitive ? currentDepth : currentDepth + 1;
-        return `${key}: ${stringifyObject(value, maxDepth, depth)}`;
-    });
-    const suffix = Object.keys(properties).length > 5 ?
-        `... (+${Object.keys(properties).length - 5} more)` : '';
-    return `{ ${props.join(', ')}${suffix} }`;
-}
-
-
-},
-"./src/utilities/uuid.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  uuid: () => (uuid),
-  uuidv4: () => (uuidv4)
-});
-const uuid = (length = 16) => {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    const charLength = chars.length;
-    let result = '';
-    for (let i = 0; i < length; i++) {
-        result += chars[Math.random() * charLength | 0];
-    }
-    return result;
-};
-const HEX_CHARS = '0123456789abcdef';
-const UUID_TEMPLATE = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
-const hasCrypto = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function';
-const uuidv4 = () => {
-    let randomBytes = null;
-    if (hasCrypto) {
-        randomBytes = crypto.getRandomValues(new Uint8Array(16));
-    }
-    let byteIndex = 0;
-    let uuid = '';
-    for (let i = 0; i < UUID_TEMPLATE.length; i++) {
-        const c = UUID_TEMPLATE[i];
-        if (c === '-') {
-            uuid += '-';
-            continue;
-        }
-        let r;
-        if (hasCrypto && randomBytes) {
-            // Each byte gives two hex digits (nibbles)
-            r =
-                (i % 2 === 0
-                    ? randomBytes[byteIndex] >> 4
-                    : randomBytes[byteIndex++] & 0x0f);
-        }
-        else {
-            r = Math.floor(Math.random() * 16);
-        }
-        if (c === 'x') {
-            uuid += HEX_CHARS[r];
-        }
-        else if (c === 'y') {
-            // Variant bits: 8, 9, A, or B
-            uuid += HEX_CHARS[(r & 0x3) | 0x8];
-        }
-        else if (c === '4') {
-            uuid += '4';
-        }
-    }
-    return uuid;
-};
-
-
-},
-
-});
-// The module cache
-var __webpack_module_cache__ = {};
-
-// The require function
-function __webpack_require__(moduleId) {
-
-// Check if module is in cache
-var cachedModule = __webpack_module_cache__[moduleId];
-if (cachedModule !== undefined) {
-return cachedModule.exports;
-}
-// Create a new module (and put it into the cache)
-var module = (__webpack_module_cache__[moduleId] = {
-exports: {}
-});
-// Execute the module function
-__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-
-// Return the exports of the module
-return module.exports;
-
-}
-
-// webpack/runtime/define_property_getters
-(() => {
-__webpack_require__.d = (exports, definition) => {
-	for(var key in definition) {
-        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
-        }
-    }
-};
-})();
-// webpack/runtime/has_own_property
-(() => {
-__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
-})();
-// webpack/runtime/make_namespace_object
-(() => {
-// define __esModule on exports
-__webpack_require__.r = (exports) => {
-	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-	}
-	Object.defineProperty(exports, '__esModule', { value: true });
-};
-})();
-var __webpack_exports__ = {};
-// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
-(() => {
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-  Capability: () => (/* reexport safe */ _Capability__rspack_import_0.Capability),
-  PerformanceCapability: () => (/* reexport safe */ _PerformanceCapability__rspack_import_1.PerformanceCapability),
-  TracingCapability: () => (/* reexport safe */ _TracingCapability__rspack_import_2.TracingCapability)
-});
-/* import */ var _Capability__rspack_import_0 = __webpack_require__("./src/capabilities/Capability.ts");
-/* import */ var _PerformanceCapability__rspack_import_1 = __webpack_require__("./src/capabilities/PerformanceCapability.ts");
-/* import */ var _TracingCapability__rspack_import_2 = __webpack_require__("./src/capabilities/TracingCapability.ts");
+;// CONCATENATED MODULE: ./src/capabilities/index.ts
 
 
 
@@ -774,9 +800,9 @@ __webpack_require__.d(__webpack_exports__, {
 
 })();
 
-var __webpack_exports__Capability = __webpack_exports__.Capability;
-var __webpack_exports__PerformanceCapability = __webpack_exports__.PerformanceCapability;
-var __webpack_exports__TracingCapability = __webpack_exports__.TracingCapability;
+var __webpack_exports__Capability = __webpack_exports__.nS;
+var __webpack_exports__PerformanceCapability = __webpack_exports__.VP;
+var __webpack_exports__TracingCapability = __webpack_exports__.XO;
 export { __webpack_exports__Capability as Capability, __webpack_exports__PerformanceCapability as PerformanceCapability, __webpack_exports__TracingCapability as TracingCapability };
 
 //# sourceMappingURL=index.js.map