@routier/core 0.0.4 → 0.0.6

package/dist/capabilities/index.js

@@ -0,0 +1,707 @@
+var __webpack_modules__ = ({
+"./src/capabilities/Capability.ts": 
+/*!****************************************!*\
+  !*** ./src/capabilities/Capability.ts ***!
+  \****************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  Capability: () => (Capability)
+});
+class Capability {
+    isValidObject(obj) {
+        return typeof obj === "object" && obj !== null;
+    }
+    getObjectName(obj) {
+        return obj?.constructor?.name || 'root';
+    }
+    exploreObjectMethods(obj, callback, options = {}) {
+        if (!this.isValidObject(obj)) {
+            return;
+        }
+        const { maxDepth = 10, includeNonEnumerable = false, filter = () => true } = options;
+        const rootName = this.getObjectName(obj);
+        const visited = new Set();
+        // Explore root methods
+        this.exploreRootMethods(obj, callback, filter);
+        // Explore nested methods
+        this.exploreNestedMethods(obj, callback, filter, [rootName], visited, maxDepth, includeNonEnumerable);
+    }
+    exploreRootMethods(obj, callback, filter) {
+        const methodNames = this.extractMethodNames(obj);
+        for (const methodName of methodNames) {
+            const methodInfo = {
+                methodName,
+                instance: obj,
+                methodPath: [String(methodName)],
+                parent: null
+            };
+            if (filter(methodInfo)) {
+                callback(methodInfo);
+            }
+        }
+    }
+    extractMethodNames(obj) {
+        const methodNames = new Set();
+        let prototype = obj;
+        while (prototype && prototype !== Object.prototype) {
+            const allKeys = [
+                ...Object.getOwnPropertyNames(prototype),
+                ...Object.getOwnPropertySymbols(prototype),
+            ];
+            for (const key of allKeys) {
+                const descriptor = Object.getOwnPropertyDescriptor(prototype, key);
+                if (this.isCallableMethod(descriptor, key)) {
+                    methodNames.add(key);
+                }
+            }
+            prototype = Object.getPrototypeOf(prototype);
+        }
+        return Array.from(methodNames);
+    }
+    isCallableMethod(descriptor, key) {
+        return (descriptor?.value &&
+            typeof descriptor.value === 'function' &&
+            key !== 'constructor' &&
+            key !== 'undefined');
+    }
+    isCustomClassInstance(value) {
+        if (value === null || (typeof value !== "object" && typeof value !== "function")) {
+            return false;
+        }
+        const objectTag = Object.prototype.toString.call(value);
+        // Most built-ins have distinct tags; user classes default to "[object Object]"
+        // Caveat: Symbol.toStringTag can spoof this.
+        return objectTag === "[object Object]";
+    }
+    shouldProcessProperty(property) {
+        return (this.isCustomClassInstance(property) &&
+            property?.constructor.name !== "Object");
+    }
+    exploreNestedMethods(obj, callback, filter, initialPath, visited, maxDepth, includeNonEnumerable) {
+        if (visited.has(obj) || initialPath.length > maxDepth) {
+            return;
+        }
+        visited.add(obj);
+        if (!this.isValidObject(obj)) {
+            return;
+        }
+        const properties = includeNonEnumerable
+            ? Object.getOwnPropertyNames(obj)
+            : Object.keys(obj);
+        for (const propertyName of properties) {
+            const property = obj[propertyName];
+            if (!this.shouldProcessProperty(property)) {
+                continue;
+            }
+            const newPath = [...initialPath, propertyName];
+            // Explore methods on this property
+            this.explorePropertyMethods(property, callback, filter, newPath, obj);
+            // Recursively explore nested objects
+            this.exploreNestedMethods(property, callback, filter, newPath, visited, maxDepth, includeNonEnumerable);
+        }
+    }
+    explorePropertyMethods(property, callback, filter, methodPath, parent) {
+        const methodNames = this.extractMethodNames(property);
+        for (const methodName of methodNames) {
+            const fullMethodPath = [...methodPath, String(methodName)];
+            const methodInfo = {
+                methodName,
+                instance: property,
+                methodPath: fullMethodPath,
+                parent
+            };
+            if (filter(methodInfo)) {
+                callback(methodInfo);
+            }
+        }
+    }
+    stringifyValue(value, maxDepth = 3, currentDepth = 0) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        const type = typeof value;
+        switch (type) {
+            case 'string':
+                return `"${value}"`;
+            case 'number':
+            case 'boolean':
+                return String(value);
+            case 'function':
+                return `[Function: ${this.getFunctionName(value)}]`;
+            case 'object':
+                if (currentDepth >= maxDepth) {
+                    return '[Max Depth Reached]';
+                }
+                return this.stringifyObject(value, maxDepth, currentDepth);
+            default:
+                return `[${type}]`;
+        }
+    }
+    getFunctionName(fn) {
+        const name = fn.name;
+        return name || 'anonymous';
+    }
+    stringifyObject(obj, maxDepth, currentDepth) {
+        if (obj === null)
+            return 'null';
+        // Handle special object types
+        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 this.stringifyArray(obj, maxDepth, currentDepth);
+        }
+        if (obj.constructor && obj.constructor.name !== 'Object') {
+            return this.stringifyClassInstance(obj, maxDepth, currentDepth);
+        }
+        return this.stringifyPlainObject(obj, maxDepth, currentDepth);
+    }
+    stringifyArray(arr, maxDepth, currentDepth) {
+        if (arr.length === 0)
+            return '[]';
+        const items = arr.slice(0, 5).map(item => this.stringifyValue(item, maxDepth, currentDepth + 1));
+        const suffix = arr.length > 5 ? `... (+${arr.length - 5} more)` : '';
+        return `[${items.join(', ')}${suffix}]`;
+    }
+    stringifyClassInstance(obj, maxDepth, currentDepth) {
+        const className = obj.constructor.name;
+        const properties = this.getObjectProperties(obj);
+        if (Object.keys(properties).length === 0) {
+            return `${className} {}`;
+        }
+        const props = Object.entries(properties)
+            .slice(0, 5)
+            .map(([key, value]) => {
+            // For primitive values, don't increase depth
+            const isPrimitive = value === null || value === undefined ||
+                (typeof value !== 'object' && typeof value !== 'function');
+            const depth = isPrimitive ? currentDepth : currentDepth + 1;
+            return `${key}: ${this.stringifyValue(value, maxDepth, depth)}`;
+        });
+        const suffix = Object.keys(properties).length > 5 ?
+            `... (+${Object.keys(properties).length - 5} more)` : '';
+        return `${className} { ${props.join(', ')}${suffix} }`;
+    }
+    stringifyPlainObject(obj, maxDepth, currentDepth) {
+        const properties = this.getObjectProperties(obj);
+        if (Object.keys(properties).length === 0) {
+            return '{}';
+        }
+        const props = Object.entries(properties)
+            .slice(0, 5)
+            .map(([key, value]) => {
+            // For primitive values, don't increase depth
+            const isPrimitive = value === null || value === undefined ||
+                (typeof value !== 'object' && typeof value !== 'function');
+            const depth = isPrimitive ? currentDepth : currentDepth + 1;
+            return `${key}: ${this.stringifyValue(value, maxDepth, depth)}`;
+        });
+        const suffix = Object.keys(properties).length > 5 ?
+            `... (+${Object.keys(properties).length - 5} more)` : '';
+        return `{ ${props.join(', ')}${suffix} }`;
+    }
+    getObjectProperties(obj) {
+        const properties = {};
+        // Get enumerable properties
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                properties[key] = obj[key];
+            }
+        }
+        return properties;
+    }
+}
+
+
+}),
+"./src/capabilities/PerformanceCapability.ts": 
+/*!***************************************************!*\
+  !*** ./src/capabilities/PerformanceCapability.ts ***!
+  \***************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  PerformanceCapability: () => (PerformanceCapability)
+});
+/* ESM import */var _Capability__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Capability */ "./src/capabilities/Capability.ts");
+/* ESM import */var _performance_PerformanceTracker__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./performance/PerformanceTracker */ "./src/capabilities/performance/PerformanceTracker.ts");
+/* ESM import */var _tracing_CallTraceManager__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./tracing/CallTraceManager */ "./src/capabilities/tracing/CallTraceManager.ts");
+
+
+
+class PerformanceCapability extends _Capability__WEBPACK_IMPORTED_MODULE_0__.Capability {
+    callTraceManager;
+    performanceTracker;
+    log;
+    shouldLog;
+    constructor(options) {
+        super();
+        this.log = options?.log ?? ((type, operationId, methodName, methodPath, performanceMetrics, isCompleted) => {
+            if (isCompleted) {
+                if (!performanceMetrics.duration)
+                    return;
+                const deltaFromStart = this.performanceTracker.getDeltaFromOperationStart(operationId, performanceMetrics.endTime || performanceMetrics.startTime);
+                console.log(`[${type} ${operationId}] ${methodName} COMPLETED`, {
+                    methodPath,
+                    performance: {
+                        deltaFromStart: this.performanceTracker.formatDuration(deltaFromStart),
+                        executionTime: this.performanceTracker.formatDuration(performanceMetrics.duration),
+                        timeToNextCall: performanceMetrics.timeToNextCall ?
+                            this.performanceTracker.formatDuration(performanceMetrics.timeToNextCall) : 'N/A'
+                    }
+                });
+                return;
+            }
+            const deltaFromStart = this.performanceTracker.getDeltaFromOperationStart(operationId, performanceMetrics.startTime);
+            console.log(`[${type} ${operationId}] ${methodName}`, {
+                methodPath,
+                performance: {
+                    deltaFromStart: this.performanceTracker.formatDuration(deltaFromStart)
+                }
+            });
+        });
+        this.shouldLog = options?.shouldLog ?? (() => true);
+        this.callTraceManager = new _tracing_CallTraceManager__WEBPACK_IMPORTED_MODULE_1__.CallTraceManager();
+        this.performanceTracker = new _performance_PerformanceTracker__WEBPACK_IMPORTED_MODULE_2__.PerformanceTracker();
+    }
+    createPerformanceInterceptor(originalMethod, methodName, methodPath, instance) {
+        return (...args) => {
+            const isNewOperation = this.callTraceManager.isNewOperation();
+            let operationId;
+            if (isNewOperation) {
+                operationId = this.callTraceManager.startNewOperation();
+                const startTime = this.performanceTracker.startMethodTiming(operationId, methodPath);
+                this.log('ORIGIN', operationId, methodName, methodPath, { startTime }, false);
+            }
+            else {
+                operationId = this.callTraceManager.getActiveOperationId();
+                // Record that the previous method is about to call this one
+                const callTrace = this.callTraceManager.getCurrentTrace();
+                const previousMethodPath = callTrace[callTrace.length - 2];
+                if (previousMethodPath) {
+                    this.performanceTracker.recordNextMethodStart(operationId, previousMethodPath);
+                }
+                const startTime = this.performanceTracker.startMethodTiming(operationId, methodPath);
+                this.log('CHILD', operationId, methodName, methodPath, { startTime }, false);
+            }
+            try {
+                const result = originalMethod.apply(instance, args);
+                return result;
+            }
+            finally {
+                // End performance tracking
+                const performanceMetrics = this.performanceTracker.endMethodTiming(operationId, methodPath);
+                // Log completion with performance metrics
+                this.log(isNewOperation ? 'ORIGIN' : 'CHILD', operationId, methodName, methodPath, performanceMetrics, true);
+                if (isNewOperation) {
+                    this.callTraceManager.endOperation();
+                    this.performanceTracker.cleanupOperation(operationId);
+                }
+            }
+        };
+    }
+    apply(instance) {
+        if (!this.isValidObject(instance)) {
+            return;
+        }
+        // Create a performance wrapper
+        const wrapper = {
+            wrapMethod: (originalMethod, methodInfo) => {
+                return this.createPerformanceInterceptor(originalMethod, String(methodInfo.methodName), methodInfo.methodPath.join(' → '), methodInfo.instance);
+            }
+        };
+        // Use the generic interception utility
+        this.exploreObjectMethods(instance, (methodInfo) => {
+            const originalMethod = methodInfo.instance[methodInfo.methodName].bind(methodInfo.instance);
+            const wrappedMethod = wrapper.wrapMethod(originalMethod, methodInfo);
+            methodInfo.instance[methodInfo.methodName] = wrappedMethod;
+        }, {});
+    }
+}
+
+
+}),
+"./src/capabilities/TracingCapability.ts": 
+/*!***********************************************!*\
+  !*** ./src/capabilities/TracingCapability.ts ***!
+  \***********************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  TracingCapability: () => (TracingCapability)
+});
+/* ESM import */var _Capability__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Capability */ "./src/capabilities/Capability.ts");
+/* ESM import */var _tracing_CallTraceManager__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./tracing/CallTraceManager */ "./src/capabilities/tracing/CallTraceManager.ts");
+
+
+class TracingCapability extends _Capability__WEBPACK_IMPORTED_MODULE_0__.Capability {
+    callTraceManager;
+    log;
+    shouldLogMethod;
+    constructor(options) {
+        super();
+        this.log = options?.log ?? ((type, operationId, methodName, methodPath, _callTrace, formattedCallTrace, args) => {
+            const stringifiedArgs = args.map(arg => this.stringifyValue(arg, 4));
+            const logData = {
+                methodPath,
+                callStack: formattedCallTrace,
+                args: stringifiedArgs
+            };
+            console.log(`[${type} ${operationId}] ${methodName}`, logData);
+        });
+        this.shouldLogMethod = options?.shouldLog ?? (() => true);
+        this.callTraceManager = new _tracing_CallTraceManager__WEBPACK_IMPORTED_MODULE_1__.CallTraceManager();
+    }
+    createTracingInterceptor(originalMethod, methodName, methodPath, instance) {
+        return (...args) => {
+            const isNewOperation = this.callTraceManager.isNewOperation();
+            let operationId;
+            let callTrace;
+            if (isNewOperation) {
+                operationId = this.callTraceManager.startNewOperation();
+                callTrace = this.callTraceManager.addMethodToTrace(methodPath);
+                const formattedCallTrace = this.callTraceManager.formatMethodPaths(callTrace);
+                this.log('ORIGIN', operationId, methodName, methodPath, callTrace, formattedCallTrace, args);
+            }
+            else {
+                operationId = this.callTraceManager.getActiveOperationId();
+                callTrace = this.callTraceManager.addMethodToTrace(methodPath);
+                const formattedCallTrace = this.callTraceManager.formatMethodPaths(callTrace);
+                this.log('CHILD', operationId, methodName, methodPath, callTrace, formattedCallTrace, args);
+            }
+            try {
+                const result = originalMethod.apply(instance, args);
+                return result;
+            }
+            finally {
+                if (isNewOperation) {
+                    this.callTraceManager.endOperation();
+                }
+                else {
+                    this.callTraceManager.removeMethodFromTrace();
+                }
+            }
+        };
+    }
+    apply(instance) {
+        if (!this.isValidObject(instance)) {
+            return;
+        }
+        const logMethodCall = (type, operationId, methodName, methodPath, callTrace, formattedCallTrace, args) => {
+            if (this.log) {
+                this.log(type, operationId, methodName, methodPath, callTrace, formattedCallTrace, args);
+                return;
+            }
+            const stringifiedArgs = args.map(arg => this.stringifyValue(arg, 4));
+            const logData = {
+                methodPath,
+                callStack: formattedCallTrace,
+                args: stringifiedArgs
+            };
+            console.log(`[${type} ${operationId}] ${methodName}`, logData);
+        };
+        // Create a tracing wrapper
+        const wrapper = {
+            wrapMethod: (originalMethod, methodInfo) => {
+                const metadata = {
+                    parent: methodInfo.parent,
+                    instance: methodInfo.instance,
+                    methodPath: methodInfo.methodPath
+                };
+                const shouldLog = this.shouldLogMethod(methodInfo.methodName, metadata);
+                if (!shouldLog) {
+                    return originalMethod; // Return unwrapped method if not logging
+                }
+                return this.createTracingInterceptor(originalMethod, String(methodInfo.methodName), methodInfo.methodPath.join(' → '), methodInfo.instance);
+            }
+        };
+        // Use the generic interception utility
+        this.exploreObjectMethods(instance, (methodInfo) => {
+            const originalMethod = methodInfo.instance[methodInfo.methodName].bind(methodInfo.instance);
+            const wrappedMethod = wrapper.wrapMethod(originalMethod, methodInfo);
+            methodInfo.instance[methodInfo.methodName] = wrappedMethod;
+        }, {});
+    }
+}
+
+
+}),
+"./src/capabilities/performance/PerformanceTracker.ts": 
+/*!************************************************************!*\
+  !*** ./src/capabilities/performance/PerformanceTracker.ts ***!
+  \************************************************************/
+(function (__unused_webpack_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": 
+/*!******************************************************!*\
+  !*** ./src/capabilities/tracing/CallTraceManager.ts ***!
+  \******************************************************/
+(function (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  CallTraceManager: () => (CallTraceManager)
+});
+/* ESM import */var _utilities__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../utilities */ "./src/utilities/uuid.ts");
+
+class CallTraceManager {
+    activeOperationId = null;
+    activeCallStack = [];
+    startNewOperation() {
+        const operationId = (0,_utilities__WEBPACK_IMPORTED_MODULE_0__.uuid)();
+        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/uuid.ts": 
+/*!*******************************!*\
+  !*** ./src/utilities/uuid.ts ***!
+  \*******************************/
+(function (__unused_webpack_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.
+(() => {
+
+/*!***********************************!*\
+  !*** ./src/capabilities/index.ts ***!
+  \***********************************/
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  Capability: () => (/* reexport safe */ _Capability__WEBPACK_IMPORTED_MODULE_0__.Capability),
+  PerformanceCapability: () => (/* reexport safe */ _PerformanceCapability__WEBPACK_IMPORTED_MODULE_1__.PerformanceCapability),
+  TracingCapability: () => (/* reexport safe */ _TracingCapability__WEBPACK_IMPORTED_MODULE_2__.TracingCapability)
+});
+/* ESM import */var _Capability__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Capability */ "./src/capabilities/Capability.ts");
+/* ESM import */var _PerformanceCapability__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./PerformanceCapability */ "./src/capabilities/PerformanceCapability.ts");
+/* ESM import */var _TracingCapability__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./TracingCapability */ "./src/capabilities/TracingCapability.ts");
+
+
+
+
+
+})();
+
+var __webpack_exports__Capability = __webpack_exports__.Capability;
+var __webpack_exports__PerformanceCapability = __webpack_exports__.PerformanceCapability;
+var __webpack_exports__TracingCapability = __webpack_exports__.TracingCapability;
+export { __webpack_exports__Capability as Capability, __webpack_exports__PerformanceCapability as PerformanceCapability, __webpack_exports__TracingCapability as TracingCapability };
+
+//# sourceMappingURL=index.js.map