@routier/core 0.0.5 → 0.0.7

package/dist/capabilities/index.js

@@ -0,0 +1,763 @@
+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 {
+    excludedNames = new Set([
+        "Array",
+        "Set",
+        "Map",
+        "AbortController",
+        "AbortSignal",
+        "SchemaString",
+        "SchemaNumber",
+        "SchemaArray",
+        "SchemaBoolean",
+        "SchemaDate",
+        "SchemaObject",
+        "SchemaDefault",
+        "SchemaDeserialize",
+        "SchemaDistinct",
+        "SchemaFrom",
+        "SchemaIdentity",
+        "SchemaIndex",
+        "SchemaKey",
+        "SchemaNullable",
+        "SchemaOptional",
+        "SchemaReadonly",
+        "SchemaSerialize",
+        "SchemaTracked",
+        "SchemaComputed",
+        "SchemaFunction",
+        "SchemaBase",
+        "SchemaDefinition"
+    ]);
+    isValidObject(obj) {
+        return typeof obj === "object" && obj !== null;
+    }
+    isCallableMethod(descriptor, key) {
+        return (descriptor?.value &&
+            typeof descriptor.value === 'function' &&
+            key !== 'constructor' &&
+            key !== 'undefined');
+    }
+    canExplore(descriptor) {
+        if (typeof descriptor.value !== "object") {
+            return false;
+        }
+        if (descriptor.value == null) {
+            return false;
+        }
+        const name = this.getName(descriptor.value);
+        if (name == null) {
+            return true;
+        }
+        return this.excludedNames.has(name) === false;
+    }
+    getName(value) {
+        if (value.constructor != null) {
+            return value.constructor.name;
+        }
+        return null;
+    }
+    getPath(info, propertyName) {
+        let parent = info.parent;
+        const path = [info.propertyName, propertyName];
+        while (parent != null) {
+            path.unshift(parent.propertyName);
+            parent = parent.parent;
+        }
+        return path.join(".");
+    }
+    explore(instance, onDiscover) {
+        if (!this.isValidObject(instance)) {
+            return;
+        }
+        const explore = [{ instance, propertyName: this.getName(instance) }];
+        const visited = new Set();
+        for (let i = 0; i < explore.length; i++) {
+            const info = explore[i];
+            const item = info.instance;
+            if (visited.has(item)) {
+                continue;
+            }
+            const allKeys = [
+                ...Object.getOwnPropertyNames(item),
+                ...Object.getOwnPropertySymbols(item),
+            ];
+            for (const key of allKeys) {
+                const descriptor = Object.getOwnPropertyDescriptor(item, key);
+                const isCallable = this.isCallableMethod(descriptor, key);
+                onDiscover(info, {
+                    name: key,
+                    isCallable
+                });
+                if (this.canExplore(descriptor) === false) {
+                    continue;
+                }
+                const path = this.getPath(info, key);
+                explore.push({ instance: descriptor.value, parent: info, propertyName: key, path });
+            }
+            visited.add(item);
+        }
+    }
+}
+
+
+}),
+"./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 _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utilities */ "./src/utilities/strings.ts");
+/* 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;
+    filter;
+    childDurations = new Map();
+    constructor(options) {
+        super();
+        this.filter = options?.filter ?? (() => true);
+        this.callTraceManager = new _tracing_CallTraceManager__WEBPACK_IMPORTED_MODULE_1__.CallTraceManager();
+        this.performanceTracker = new _performance_PerformanceTracker__WEBPACK_IMPORTED_MODULE_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;
+                    let depth;
+                    if (isNewOperation) {
+                        operationId = this.callTraceManager.startNewOperation();
+                        this.childDurations.set(operationId, []);
+                        callTrace = this.callTraceManager.addMethodToTrace(path);
+                        depth = callTrace.length - 1;
+                        const formattedCallTrace = this.callTraceManager.formatMethodPaths(callTrace);
+                        this.performanceTracker.startMethodTiming(operationId, path);
+                        console.log(`\n${'═'.repeat(60)}`);
+                        console.log(`▶ ORIGIN [${operationId}] ${path}`);
+                        if (args.length > 0) {
+                            console.log(`  Args:`, (0,_utilities__WEBPACK_IMPORTED_MODULE_3__.stringifyObject)(args, 4, 0));
+                        }
+                        console.log(`  Call Stack: ${formattedCallTrace.join(' → ')}`);
+                    }
+                    else {
+                        operationId = this.callTraceManager.getActiveOperationId();
+                        callTrace = this.callTraceManager.addMethodToTrace(path);
+                        depth = callTrace.length - 1;
+                        const indent = '  '.repeat(Math.min(depth, 4));
+                        // Track children for this child method too
+                        const childMethodKey = `${operationId}:${path}`;
+                        this.childDurations.set(childMethodKey, []);
+                        this.performanceTracker.startMethodTiming(operationId, path);
+                        console.log(`${indent}└─ CHILD [${operationId}] ${path}`);
+                        if (args.length > 0) {
+                            console.log(`${indent}   Args:`, (0,_utilities__WEBPACK_IMPORTED_MODULE_3__.stringifyObject)(args, 4, 0));
+                        }
+                    }
+                    try {
+                        return originalMethod(...args);
+                    }
+                    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 formattedTotalChildTime = this.performanceTracker.formatDuration(totalChildTime);
+                            const overhead = duration - totalChildTime;
+                            const formattedOverhead = this.performanceTracker.formatDuration(Math.max(0, overhead));
+                            console.log(`\n${'═'.repeat(60)}`);
+                            console.log(`◀ COMPLETE [${operationId}] ${path}`);
+                            console.log(`  Total Duration: ${formattedDuration}`);
+                            if (childDurations.length > 0) {
+                                console.log(`  Children Duration: ${formattedTotalChildTime} (${childDurations.length} calls)`);
+                                console.log(`  Overhead: ${formattedOverhead}`);
+                            }
+                            console.log(`${'═'.repeat(60)}\n`);
+                            this.childDurations.delete(operationId);
+                            this.performanceTracker.cleanupOperation(operationId);
+                            this.callTraceManager.endOperation();
+                        }
+                        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 formattedTotalChildTime = this.performanceTracker.formatDuration(totalChildTime);
+                            const overhead = duration - totalChildTime;
+                            const formattedOverhead = this.performanceTracker.formatDuration(Math.max(0, overhead));
+                            console.log(`${indent}   ✓ ${formattedDuration}`);
+                            if (childDurations.length > 0) {
+                                console.log(`${indent}     Children: ${formattedTotalChildTime} (${childDurations.length} calls), Overhead: ${formattedOverhead}`);
+                            }
+                            // Clean up child method tracking
+                            this.childDurations.delete(childMethodKey);
+                            // Find the parent method and add this duration to its children list
+                            // The parent is the method one level up in the call trace
+                            const currentTrace = this.callTraceManager.getCurrentTrace();
+                            if (currentTrace.length > 1) {
+                                // Parent is the second-to-last item in the trace (before we remove current)
+                                const parentPath = currentTrace[currentTrace.length - 2];
+                                // Check if parent is the root operation (trace length 2 means root + this child)
+                                if (currentTrace.length === 2) {
+                                    // Direct child of root - add to root's children list
+                                    const rootChildDurations = this.childDurations.get(operationId);
+                                    if (rootChildDurations) {
+                                        rootChildDurations.push(duration);
+                                    }
+                                }
+                                else {
+                                    // Nested child - add to parent method's children list
+                                    const parentMethodKey = `${operationId}:${parentPath}`;
+                                    const parentChildDurations = this.childDurations.get(parentMethodKey);
+                                    if (parentChildDurations) {
+                                        parentChildDurations.push(duration);
+                                    }
+                                }
+                            }
+                        }
+                        this.callTraceManager.removeMethodFromTrace();
+                    }
+                };
+            }
+        });
+    }
+}
+
+
+}),
+"./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");
+/* ESM import */var _utilities_strings__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utilities/strings */ "./src/utilities/strings.ts");
+
+
+
+class TracingCapability extends _Capability__WEBPACK_IMPORTED_MODULE_0__.Capability {
+    callTraceManager;
+    filter;
+    constructor(options) {
+        super();
+        this.filter = options?.filter ?? (() => true);
+        this.callTraceManager = new _tracing_CallTraceManager__WEBPACK_IMPORTED_MODULE_1__.CallTraceManager();
+    }
+    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;
+                    if (isNewOperation) {
+                        operationId = this.callTraceManager.startNewOperation();
+                        const callTrace = this.callTraceManager.addMethodToTrace(path);
+                        const formattedCallTrace = this.callTraceManager.formatMethodPaths(callTrace);
+                        console.log(`\n${'═'.repeat(60)}`);
+                        console.log(`▶ ORIGIN [${operationId}] ${path}`);
+                        if (args.length > 0) {
+                            console.log(`  Args:`, (0,_utilities_strings__WEBPACK_IMPORTED_MODULE_2__.stringifyObject)(args, 4, 0));
+                        }
+                        console.log(`  Call Stack: ${formattedCallTrace.join(' → ')}`);
+                    }
+                    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__WEBPACK_IMPORTED_MODULE_2__.stringifyObject)(args, 4, 0));
+                        }
+                    }
+                    try {
+                        return originalMethod(...args);
+                    }
+                    finally {
+                        this.callTraceManager.removeMethodFromTrace();
+                        if (isNewOperation) {
+                            this.callTraceManager.endOperation();
+                        }
+                    }
+                };
+            }
+        });
+    }
+}
+
+
+}),
+"./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)(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/strings.ts": 
+/*!**********************************!*\
+  !*** ./src/utilities/strings.ts ***!
+  \**********************************/
+(function (__unused_webpack_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": 
+/*!*******************************!*\
+  !*** ./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