🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
checkpoint: File edit:
rUv5f5c4f7d4b98
diff --git a/v3/__tests__/unit/security/token-generator.test.ts b/v3/__tests__/unit/security/token-generator.test.tsnew file mode 100644index 0000000000..85bfdb48cd--- /dev/null+++ b/v3/__tests__/unit/security/token-generator.test.ts@@ -0,0 +1,310 @@+import { describe, it, expect, vi, beforeEach } from 'vitest';+import { TokenGenerator, TokenGeneratorError } from '../../../security/token-generator.js';++describe('TokenGenerator', () => {+ describe('cryptographically secure token generation', () => {+ it('should generate tokens using crypto.randomBytes', () => {+ const generator = new TokenGenerator();+ const token = generator.generate();++ // Token should be base64url encoded (default)+ expect(token).toMatch(/^[A-Za-z0-9_-]+$/);+ expect(token.length).toBeGreaterThan(0);+ });++ it('should generate tokens with specified length', () => {+ const generator = new TokenGenerator();++ // 16 bytes = 22 chars in base64url (without padding)+ const token16 = generator.generate(16);+ expect(token16.length).toBe(22);++ // 32 bytes = 43 chars in base64url (without padding)+ const token32 = generator.generate(32);+ expect(token32.length).toBe(43);+ });++ it('should support different encodings', () => {+ const hexGenerator = new TokenGenerator({ encoding: 'hex' });+ const hexToken = hexGenerator.generate(16);+ expect(hexToken).toMatch(/^[0-9a-f]+$/i);+ expect(hexToken.length).toBe(32); // 16 bytes = 32 hex chars++ const base64Generator = new TokenGenerator({ encoding: 'base64' });+ const base64Token = base64Generator.generate(16);+ expect(base64Token).toMatch(/^[A-Za-z0-9+/]+=*$/);+ });++ it('should reject token length below 16 bytes', () => {+ expect(() => new TokenGenerator({ defaultLength: 8 }))+ .toThrow('Token length must be at least 16 bytes');+ });+ });++ describe('token uniqueness', () => {+ it('should generate unique tokens each time', () => {+ const generator = new TokenGenerator();+ const tokens = new Set(Array.from({ length: 1000 }, () => generator.generate()));+ expect(tokens.size).toBe(1000);+ });++ it('should generate unique session tokens', () => {+ const generator = new TokenGenerator();+ const tokens = new Set(Array.from({ length: 100 }, () => generator.generateSessionToken().value));+ expect(tokens.size).toBe(100);+ });++ it('should generate unique verification codes', () => {+ const generator = new TokenGenerator();+ const codes = new Set(Array.from({ length: 100 }, () => generator.generateVerificationCode().code));+ // Due to 6-digit codes, some collisions are possible but should be rare+ expect(codes.size).toBeGreaterThan(90);+ });++ it('should generate unique request IDs', () => {+ const generator = new TokenGenerator();+ const ids = new Set(Array.from({ length: 1000 }, () => generator.generateRequestId()));+ expect(ids.size).toBe(1000);+ });++ it('should generate unique correlation IDs', () => {+ const generator = new TokenGenerator();+ const ids = new Set(Array.from({ length: 1000 }, () => generator.generateCorrelationId()));+ expect(ids.size).toBe(1000);+ });+ });++ describe('timing-safe comparison', () => {+ it('should return true for equal tokens', () => {+ const generator = new TokenGenerator();+ const token = generator.generate();+ expect(generator.compare(token, token)).toBe(true);+ });++ it('should return false for different tokens', () => {+ const generator = new TokenGenerator();+ const token1 = generator.generate();+ const token2 = generator.generate();+ expect(generator.compare(token1, token2)).toBe(false);+ });++ it('should return false for different length strings', () => {+ const generator = new TokenGenerator();+ expect(generator.compare('short', 'muchlongerstring')).toBe(false);+ });++ it('should perform constant-time comparison', () => {+ const generator = new TokenGenerator();+ const token = 'a'.repeat(100);++ // Compare with identical string should work+ expect(generator.compare(token, token)).toBe(true);++ // Compare with different strings at various positions+ const differentAtStart = 'b' + 'a'.repeat(99);+ const differentAtEnd = 'a'.repeat(99) + 'b';++ expect(generator.compare(token, differentAtStart)).toBe(false);+ expect(generator.compare(token, differentAtEnd)).toBe(false);+ });+ });++ describe('signed tokens', () => {+ it('should require HMAC secret for signed tokens', () => {+ const generator = new TokenGenerator();+ expect(() => generator.generateSignedToken({ userId: '123' }))+ .toThrow('HMAC secret required for signed tokens');+ });++ it('should generate valid signed tokens', () => {+ const generator = new TokenGenerator({ hmacSecret: 'test-secret-key-123' });+ const signed = generator.generateSignedToken({ userId: '123' });++ expect(signed.token).toBeDefined();+ expect(signed.signature).toBeDefined();+ expect(signed.combined).toBe(`${signed.token}.${signed.signature}`);+ expect(signed.createdAt).toBeInstanceOf(Date);+ expect(signed.expiresAt).toBeInstanceOf(Date);+ });++ it('should verify valid signed tokens', () => {+ const generator = new TokenGenerator({ hmacSecret: 'test-secret-key-123' });+ const signed = generator.generateSignedToken({ userId: '123', role: 'admin' });++ const payload = generator.verifySignedToken(signed.combined);+ expect(payload).not.toBeNull();+ expect(payload!.userId).toBe('123');+ expect(payload!.role).toBe('admin');+ });++ it('should reject tampered tokens', () => {+ const generator = new TokenGenerator({ hmacSecret: 'test-secret-key-123' });+ const signed = generator.generateSignedToken({ userId: '123' });++ // Tamper with signature+ const tampered = signed.combined.slice(0, -5) + 'xxxxx';+ expect(generator.verifySignedToken(tampered)).toBeNull();+ });++ it('should reject tokens with wrong secret', () => {+ const generator1 = new TokenGenerator({ hmacSecret: 'secret-1' });+ const generator2 = new TokenGenerator({ hmacSecret: 'secret-2' });++ const signed = generator1.generateSignedToken({ userId: '123' });+ expect(generator2.verifySignedToken(signed.combined)).toBeNull();+ });++ it('should reject expired signed tokens', async () => {+ const generator = new TokenGenerator({ hmacSecret: 'test-secret' });+ const signed = generator.generateSignedToken({ userId: '123' }, 0); // Expires immediately++ // Wait a tiny bit for expiration+ await new Promise(resolve => setTimeout(resolve, 10));+ expect(generator.verifySignedToken(signed.combined)).toBeNull();+ });++ it('should reject malformed token format', () => {+ const generator = new TokenGenerator({ hmacSecret: 'test-secret' });++ expect(generator.verifySignedToken('no-dot-in-token')).toBeNull();+ expect(generator.verifySignedToken('too.many.dots')).toBeNull();+ expect(generator.verifySignedToken('')).toBeNull();+ });+ });++ describe('token expiration', () => {+ it('should create tokens with expiration', () => {+ const generator = new TokenGenerator();+ const token = generator.generateWithExpiration(3600);++ expect(token.expiresAt.getTime()).toBe(token.createdAt.getTime() + 3600 * 1000);+ });++ it('should use default expiration', () => {+ const generator = new TokenGenerator({ defaultExpiration: 7200 });+ const token = generator.generateWithExpiration();++ expect(token.expiresAt.getTime()).toBe(token.createdAt.getTime() + 7200 * 1000);+ });++ it('should correctly identify expired tokens', () => {+ const generator = new TokenGenerator();++ const expiredToken = {+ value: 'test',+ createdAt: new Date(Date.now() - 10000),+ expiresAt: new Date(Date.now() - 5000),+ };+ expect(generator.isExpired(expiredToken)).toBe(true);++ const validToken = {+ value: 'test',+ createdAt: new Date(),+ expiresAt: new Date(Date.now() + 10000),+ };+ expect(generator.isExpired(validToken)).toBe(false);+ });+ });++ describe('specialized token types', () => {+ it('should generate session tokens with expiration', () => {+ const generator = new TokenGenerator();+ const token = generator.generateSessionToken();++ expect(token.value).toBeDefined();+ expect(token.expiresAt.getTime()).toBeGreaterThan(token.createdAt.getTime());+ });++ it('should generate CSRF tokens with 30-minute expiration', () => {+ const generator = new TokenGenerator();+ const token = generator.generateCsrfToken();++ const expectedExpiry = token.createdAt.getTime() + 1800 * 1000;+ expect(token.expiresAt.getTime()).toBe(expectedExpiry);+ });++ it('should generate API tokens with prefix and 1-year expiration', () => {+ const generator = new TokenGenerator();+ const token = generator.generateApiToken('api_');++ expect(token.value.startsWith('api_')).toBe(true);++ const oneYear = 365 * 24 * 60 * 60 * 1000;+ expect(token.expiresAt.getTime()).toBeCloseTo(token.createdAt.getTime() + oneYear, -3);+ });++ it('should generate password reset tokens with 30-minute expiration', () => {+ const generator = new TokenGenerator();+ const token = generator.generatePasswordResetToken();++ const expectedExpiry = token.createdAt.getTime() + 1800 * 1000;+ expect(token.expiresAt.getTime()).toBe(expectedExpiry);+ });++ it('should generate email verification tokens with 24-hour expiration', () => {+ const generator = new TokenGenerator();+ const token = generator.generateEmailVerificationToken();++ const expectedExpiry = token.createdAt.getTime() + 86400 * 1000;+ expect(token.expiresAt.getTime()).toBe(expectedExpiry);+ });++ it('should generate token pairs (access + refresh)', () => {+ const generator = new TokenGenerator();+ const pair = generator.generateTokenPair();++ expect(pair.accessToken).toBeDefined();+ expect(pair.refreshToken).toBeDefined();++ // Access token: 15 minutes+ expect(pair.accessToken.expiresAt.getTime()).toBe(+ pair.accessToken.createdAt.getTime() + 900 * 1000+ );++ // Refresh token: 7 days+ expect(pair.refreshToken.expiresAt.getTime()).toBe(+ pair.refreshToken.createdAt.getTime() + 604800 * 1000+ );+ });+ });++ describe('verification codes', () => {+ it('should generate numeric codes of specified length', () => {+ const generator = new TokenGenerator();++ const code6 = generator.generateVerificationCode(6);+ expect(code6.code).toMatch(/^\d{6}$/);++ const code8 = generator.generateVerificationCode(8);+ expect(code8.code).toMatch(/^\d{8}$/);+ });++ it('should set expiration and attempt limits', () => {+ const generator = new TokenGenerator();+ const code = generator.generateVerificationCode(6, 15, 5);++ expect(code.attempts).toBe(0);+ expect(code.maxAttempts).toBe(5);+ expect(code.expiresAt.getTime()).toBe(code.createdAt.getTime() + 15 * 60 * 1000);+ });+ });++ describe('correlation and request IDs', () => {+ it('should generate short request IDs', () => {+ const generator = new TokenGenerator();+ const id = generator.generateRequestId();++ // 8 bytes = 11 chars in base64url+ expect(id.length).toBe(11);+ });++ it('should generate correlation IDs with timestamp prefix', () => {+ const generator = new TokenGenerator();+ const id = generator.generateCorrelationId();++ expect(id).toMatch(/^[a-z0-9]+-[A-Za-z0-9_-]+$/);+ const [timestamp] = id.split('-');+ expect(parseInt(timestamp, 36)).toBeGreaterThan(0);+ });+ });+});diff --git a/v3/hooks/composition.ts b/v3/hooks/composition.tsnew file mode 100644index 0000000000..5d7d4d1a29--- /dev/null+++ b/v3/hooks/composition.ts@@ -0,0 +1,425 @@+/**+ * V3 Hook Composition+ * Utilities for composing and chaining hooks+ */++import type {+ HookHandler,+ HookContext,+ HookPayload,+ HookResult,+ HookChain,+ CompositionResult,+ HookCombinators+} from './types.js';++/**+ * Hook composition utilities+ */+export class HookComposer implements HookCombinators {+ /**+ * Pipe hooks in sequence, passing result to next+ * Each hook receives the output of the previous hook+ */+ pipe<T>(...handlers: HookHandler<T>[]): HookHandler<T> {+ return async (payload: HookPayload<T>, context: HookContext): Promise<HookResult<T>> => {+ let currentData = payload.data;+ let lastResult: HookResult<T> = { continue: true, modified: false };++ for (const handler of handlers) {+ const currentPayload: HookPayload<T> = {+ ...payload,+ data: currentData+ };++ const result = await handler(currentPayload, context);+ lastResult = result;++ if (result.modified && result.data !== undefined) {+ currentData = result.data;+ }++ if (!result.continue) {+ break;+ }+ }++ return {+ ...lastResult,+ data: currentData,+ modified: currentData !== payload.data+ };+ };+ }++ /**+ * Execute hooks in parallel and wait for all to complete+ */+ parallel<T>(...handlers: HookHandler<T>[]): HookHandler<T> {+ return async (payload: HookPayload<T>, context: HookContext): Promise<HookResult<T>> => {+ const results = await Promise.all(+ handlers.map(handler => handler(payload, context))+ );++ // Aggregate results+ const errors = results.filter(r => r.error).map(r => r.error!);+ const allContinue = results.every(r => r.continue);+ const anyModified = results.some(r => r.modified);++ // Merge side effects+ const sideEffects = results.flatMap(r => r.sideEffects || []);++ return {+ continue: allContinue,+ modified: anyModified,+ data: payload.data, // Parallel doesn't modify data+ sideEffects: sideEffects.length > 0 ? sideEffects : undefined,+ error: errors.length > 0 ? errors[0] : undefined+ };+ };+ }++ /**+ * Execute hooks in parallel, return first successful result+ */+ race<T>(...handlers: HookHandler<T>[]): HookHandler<T> {+ return async (payload: HookPayload<T>, context: HookContext): Promise<HookResult<T>> => {+ return new Promise((resolve) => {+ let resolved = false;+ const errors: Error[] = [];++ handlers.forEach(handler => {+ handler(payload, context)+ .then(result => {+ if (resolved) return;++ if (!result.error) {+ resolved = true;+ resolve(result);+ } else {+ errors.push(result.error);++ // If all failed, resolve with error+ if (errors.length === handlers.length) {+ resolve({+ continue: true,+ modified: false,+ error: errors[0]+ });+ }+ }+ })+ .catch(error => {+ errors.push(error);+ if (errors.length === handlers.length && !resolved) {+ resolve({+ continue: true,+ modified: false,+ error: errors[0]+ });+ }+ });+ });+ });+ };+ }++ /**+ * Execute hooks and merge their data results+ */+ merge<T>(...handlers: HookHandler<T>[]): HookHandler<T> {+ return async (payload: HookPayload<T>, context: HookContext): Promise<HookResult<T>> => {+ const results = await Promise.all(+ handlers.map(handler => handler(payload, context))+ );++ // Merge all modified data+ let mergedData = payload.data;++ for (const result of results) {+ if (result.modified && result.data !== undefined) {+ if (typeof mergedData === 'object' && typeof result.data === 'object') {+ mergedData = { ...mergedData as object, ...result.data as object } as T;+ } else {+ mergedData = result.data;+ }+ }+ }++ // Merge side effects+ const sideEffects = results.flatMap(r => r.sideEffects || []);++ return {+ continue: results.every(r => r.continue),+ modified: mergedData !== payload.data,+ data: mergedData,+ sideEffects: sideEffects.length > 0 ? sideEffects : undefined+ };+ };+ }++ /**+ * Conditionally execute hook based on predicate+ */+ when<T>(+ condition: (ctx: HookContext) => boolean,+ handler: HookHandler<T>+ ): HookHandler<T> {+ return async (payload: HookPayload<T>, context: HookContext): Promise<HookResult<T>> => {+ if (condition(context)) {+ return handler(payload, context);+ }++ return {+ continue: true,+ modified: false+ };+ };+ }++ /**+ * Retry hook on failure with exponential backoff+ */+ retry<T>(+ handler: HookHandler<T>,+ attempts: number,+ delay: number = 1000+ ): HookHandler<T> {+ return async (payload: HookPayload<T>, context: HookContext): Promise<HookResult<T>> => {+ let lastError: Error | undefined;++ for (let i = 0; i < attempts; i++) {+ try {+ const result = await handler(payload, context);++ if (!result.error) {+ return result;+ }++ lastError = result.error;+ } catch (error) {+ lastError = error as Error;+ }++ if (i < attempts - 1) {+ await this.delay(delay * Math.pow(2, i));+ }+ }++ return {+ continue: true,+ modified: false,+ error: lastError+ };+ };+ }++ /**+ * Add timeout to hook execution+ */+ timeout<T>(handler: HookHandler<T>, ms: number): HookHandler<T> {+ return async (payload: HookPayload<T>, context: HookContext): Promise<HookResult<T>> => {+ return Promise.race([+ handler(payload, context),+ new Promise<HookResult<T>>((_, reject) => {+ setTimeout(() => {+ reject(new Error(`Hook timed out after ${ms}ms`));+ }, ms);+ })+ ]).catch(error => ({+ continue: true,+ modified: false,+ error+ }));+ };+ }++ /**+ * Cache hook results+ */+ cache<T>(+ handler: HookHandler<T>,+ ttl: number,+ keyFn?: (payload: HookPayload<T>) => string+ ): HookHandler<T> {+ const cache = new Map<string, { result: HookResult<T>; expires: number }>();++ return async (payload: HookPayload<T>, context: HookContext): Promise<HookResult<T>> => {+ const key = keyFn+ ? keyFn(payload)+ : JSON.stringify(payload.data);++ const cached = cache.get(key);++ if (cached && cached.expires > Date.now()) {+ return {+ ...cached.result,+ metrics: {+ ...cached.result.metrics,+ duration: 0+ }+ };+ }++ const result = await handler(payload, context);++ cache.set(key, {+ result,+ expires: Date.now() + ttl+ });++ return result;+ };+ }++ /**+ * Execute hook only if previous result matches condition+ */+ ifResult<T>(+ condition: (result: HookResult<T>) => boolean,+ handler: HookHandler<T>+ ): HookHandler<T> {+ let lastResult: HookResult<T> | undefined;++ return async (payload: HookPayload<T>, context: HookContext): Promise<HookResult<T>> => {+ if (lastResult && condition(lastResult)) {+ const result = await handler(payload, context);+ lastResult = result;+ return result;+ }++ // Execute and store result for next check+ lastResult = {+ continue: true,+ modified: false,+ data: payload.data+ };++ return lastResult;+ };+ }++ /**+ * Add logging/tracing to hook+ */+ trace<T>(+ handler: HookHandler<T>,+ name: string,+ logger?: (msg: string, data?: unknown) => void+ ): HookHandler<T> {+ const log = logger || console.log;++ return async (payload: HookPayload<T>, context: HookContext): Promise<HookResult<T>> => {+ const start = Date.now();+ log(`[${name}] Starting`, { hookType: context.hookType });++ try {+ const result = await handler(payload, context);+ const duration = Date.now() - start;++ log(`[${name}] Completed`, {+ hookType: context.hookType,+ duration,+ modified: result.modified,+ continue: result.continue+ });++ return result;+ } catch (error) {+ const duration = Date.now() - start;+ log(`[${name}] Error`, {+ hookType: context.hookType,+ duration,+ error: (error as Error).message+ });++ throw error;+ }+ };+ }++ /**+ * Create a hook chain from configuration+ */+ createChain<T>(config: HookChain): HookHandler<T> {+ const handlers = config.hooks.map(h => h.handler) as HookHandler<T>[];++ switch (config.mode) {+ case 'serial':+ return this.pipe(...handlers);++ case 'waterfall':+ return this.pipe(...handlers);++ case 'parallel':+ return this.parallel(...handlers);++ case 'race':+ return this.race(...handlers);++ default:+ return this.pipe(...handlers);+ }+ }++ /**+ * Execute a hook chain+ */+ async executeChain<T>(+ chain: HookChain,+ payload: T,+ context: HookContext+ ): Promise<CompositionResult<T>> {+ const startTime = Date.now();+ const handler = this.createChain<T>(chain);++ const hookPayload: HookPayload<T> = {+ data: payload,+ context,+ modifiable: true+ };++ try {+ const result = await handler(hookPayload, context);++ return {+ success: !result.error,+ results: [result],+ aggregatedData: result.modified ? result.data : payload,+ errors: result.error ? [result.error] : [],+ duration: Date.now() - startTime,+ hookCount: chain.hooks.length+ };+ } catch (error) {+ return {+ success: false,+ results: [],+ errors: [error as Error],+ duration: Date.now() - startTime,+ hookCount: chain.hooks.length+ };+ }+ }++ // ============================================+ // Private Methods+ // ============================================++ private delay(ms: number): Promise<void> {+ return new Promise(resolve => setTimeout(resolve, ms));+ }+}++// Export singleton instance and convenience functions+export const composer = new HookComposer();++// Re-export convenience functions+export const pipe = composer.pipe.bind(composer);+export const parallel = composer.parallel.bind(composer);+export const race = composer.race.bind(composer);+export const merge = composer.merge.bind(composer);+export const when = composer.when.bind(composer);+export const retry = composer.retry.bind(composer);+export const timeout = composer.timeout.bind(composer);+export const cache = composer.cache.bind(composer);+export const trace = composer.trace.bind(composer);diff --git a/v3/hooks/hook-executor.ts b/v3/hooks/hook-executor.tsnew file mode 100644index 0000000000..c329600a69--- /dev/null+++ b/v3/hooks/hook-executor.ts@@ -0,0 +1,416 @@+/**+ * V3 Hook Executor+ * Executes hooks with error handling, retries, and timeout support+ */++import type {+ HookType,+ HookRegistration,+ HookContext,+ HookPayload,+ HookResult,+ HookMetrics,+ HookOptions,+ SideEffect,+ HookError,+ HookTimeoutError+} from './types.js';+import { HookRegistry, hookRegistry } from './hook-registry.js';++/**+ * Executor options+ */+export interface ExecutorOptions {+ /** Default timeout for all hooks */+ defaultTimeout?: number;+ /** Default retry count */+ defaultRetries?: number;+ /** Default retry delay */+ defaultRetryDelay?: number;+ /** Whether to collect metrics */+ collectMetrics?: boolean;+ /** Whether to process side effects */+ processSideEffects?: boolean;+ /** Side effect handler */+ sideEffectHandler?: (effect: SideEffect, context: HookContext) => Promise<void>;+}++/**+ * Execution result with full details+ */+export interface ExecutionResult<T = unknown> {+ hookId: string;+ hookType: HookType;+ result: HookResult<T>;+ metrics: HookMetrics;+ error?: Error;+ retryCount: number;+}++/**+ * Hook executor+ */+export class HookExecutor {+ private registry: HookRegistry;+ private options: ExecutorOptions;+ private activeExecutions: Set<string> = new Set();++ constructor(registry: HookRegistry = hookRegistry, options: ExecutorOptions = {}) {+ this.registry = registry;+ this.options = {+ defaultTimeout: 30000,+ defaultRetries: 0,+ defaultRetryDelay: 1000,+ collectMetrics: true,+ processSideEffects: true,+ ...options+ };+ }++ /**+ * Execute a single hook+ */+ async executeHook<TPayload, TResult>(+ registration: HookRegistration<TPayload, TResult>,+ payload: HookPayload<TPayload>,+ context: HookContext+ ): Promise<ExecutionResult<TResult>> {+ const executionId = this.generateExecutionId();+ const startTime = Date.now();+ let retryCount = 0;+ let lastError: Error | undefined;++ this.activeExecutions.add(executionId);++ const hookOptions = registration.options || {};+ const timeout = hookOptions.timeout || this.options.defaultTimeout!;+ const maxRetries = hookOptions.retries || this.options.defaultRetries!;+ const retryDelay = hookOptions.retryDelay || this.options.defaultRetryDelay!;++ try {+ while (retryCount <= maxRetries) {+ try {+ // Execute with timeout+ const result = await this.executeWithTimeout<TResult>(+ () => registration.handler(payload, context) as Promise<HookResult<TResult>>,+ timeout,+ registration.id,+ registration.type+ );++ // Process side effects+ if (result.sideEffects && this.options.processSideEffects && this.options.sideEffectHandler) {+ await this.processSideEffects(result.sideEffects, context);+ }++ // Update statistics+ if (this.options.collectMetrics) {+ const duration = Date.now() - startTime;+ this.registry.updateStatistics(registration.id, {+ totalExecutions: 1,+ successfulExecutions: 1,+ duration+ });+ }++ return {+ hookId: registration.id,+ hookType: registration.type,+ result,+ metrics: {+ duration: Date.now() - startTime,+ cached: false+ },+ retryCount+ };++ } catch (error) {+ lastError = error as Error;+ retryCount++;++ if (retryCount <= maxRetries) {+ // Wait before retry+ await this.delay(retryDelay * Math.pow(2, retryCount - 1)); // Exponential backoff+ }+ }+ }++ // All retries exhausted+ if (this.options.collectMetrics) {+ this.registry.updateStatistics(registration.id, {+ totalExecutions: 1,+ failedExecutions: 1,+ duration: Date.now() - startTime+ });+ }++ // Try fallback if available+ if (hookOptions.fallback) {+ try {+ const fallbackResult = await hookOptions.fallback(payload, context) as HookResult<TResult>;+ return {+ hookId: registration.id,+ hookType: registration.type,+ result: fallbackResult,+ metrics: {+ duration: Date.now() - startTime,+ cached: false+ },+ retryCount,+ error: lastError+ };+ } catch (fallbackError) {+ lastError = fallbackError as Error;+ }+ }++ // Call error handler if available+ if (hookOptions.onError && lastError) {+ hookOptions.onError(lastError, context);+ }++ // Return error result+ return {+ hookId: registration.id,+ hookType: registration.type,+ result: {+ continue: true, // Default to continue even on error+ modified: false,+ error: lastError+ },+ metrics: {+ duration: Date.now() - startTime+ },+ error: lastError,+ retryCount+ };++ } finally {+ this.activeExecutions.delete(executionId);+ }+ }++ /**+ * Execute all hooks for a type+ */+ async executeAll<TPayload, TResult>(+ type: HookType,+ payload: TPayload,+ context: Partial<HookContext> = {}+ ): Promise<ExecutionResult<TResult>[]> {+ const fullContext = this.buildContext(type, context);+ const hooks = this.registry.getByType(type).filter(h => h.enabled);++ if (hooks.length === 0) {+ return [];+ }++ const results: ExecutionResult<TResult>[] = [];+ let currentPayload = payload;++ for (const hook of hooks) {+ const hookPayload: HookPayload<TPayload> = {+ data: currentPayload,+ context: fullContext,+ modifiable: true+ };++ const result = await this.executeHook<TPayload, TResult>(+ hook as HookRegistration<TPayload, TResult>,+ hookPayload,+ fullContext+ );++ results.push(result);++ // Update payload if modified+ if (result.result.modified && result.result.data !== undefined) {+ currentPayload = result.result.data as unknown as TPayload;+ }++ // Stop if hook returns continue: false+ if (!result.result.continue) {+ break;+ }+ }++ return results;+ }++ /**+ * Execute hooks in parallel+ */+ async executeParallel<TPayload, TResult>(+ type: HookType,+ payload: TPayload,+ context: Partial<HookContext> = {}+ ): Promise<ExecutionResult<TResult>[]> {+ const fullContext = this.buildContext(type, context);+ const hooks = this.registry.getByType(type).filter(h => h.enabled);++ if (hooks.length === 0) {+ return [];+ }++ const hookPayload: HookPayload<TPayload> = {+ data: payload,+ context: fullContext,+ modifiable: false // Parallel execution shouldn't modify shared payload+ };++ const promises = hooks.map(hook =>+ this.executeHook<TPayload, TResult>(+ hook as HookRegistration<TPayload, TResult>,+ hookPayload,+ fullContext+ )+ );++ return Promise.all(promises);+ }++ /**+ * Execute hooks with race semantics (first success wins)+ */+ async executeRace<TPayload, TResult>(+ type: HookType,+ payload: TPayload,+ context: Partial<HookContext> = {}+ ): Promise<ExecutionResult<TResult> | null> {+ const fullContext = this.buildContext(type, context);+ const hooks = this.registry.getByType(type).filter(h => h.enabled);++ if (hooks.length === 0) {+ return null;+ }++ const hookPayload: HookPayload<TPayload> = {+ data: payload,+ context: fullContext,+ modifiable: false+ };++ return new Promise((resolve) => {+ let resolved = false;+ const results: ExecutionResult<TResult>[] = [];++ for (const hook of hooks) {+ this.executeHook<TPayload, TResult>(+ hook as HookRegistration<TPayload, TResult>,+ hookPayload,+ fullContext+ ).then(result => {+ if (resolved) return;++ if (!result.error && result.result.continue) {+ resolved = true;+ resolve(result);+ } else {+ results.push(result);++ // If all failed, return the first result+ if (results.length === hooks.length) {+ resolve(results[0]);+ }+ }+ });+ }+ });+ }++ /**+ * Get active execution count+ */+ getActiveCount(): number {+ return this.activeExecutions.size;+ }++ /**+ * Cancel all active executions+ */+ cancelAll(): void {+ // In a real implementation, this would abort all running hooks+ // For now, just clear the set+ this.activeExecutions.clear();+ }++ // ============================================+ // Private Methods+ // ============================================++ /**+ * Execute with timeout+ */+ private async executeWithTimeout<T>(+ fn: () => Promise<HookResult<T>>,+ timeout: number,+ hookId: string,+ hookType: HookType+ ): Promise<HookResult<T>> {+ return Promise.race([+ fn(),+ new Promise<HookResult<T>>((_, reject) => {+ setTimeout(() => {+ reject(this.createTimeoutError(hookId, hookType, timeout));+ }, timeout);+ })+ ]);+ }++ /**+ * Process side effects+ */+ private async processSideEffects(effects: SideEffect[], context: HookContext): Promise<void> {+ if (!this.options.sideEffectHandler) return;++ for (const effect of effects) {+ try {+ await this.options.sideEffectHandler(effect, context);+ } catch (error) {+ // Log but don't fail on side effect errors+ console.error(`Side effect error (${effect.type}):`, error);+ }+ }+ }++ /**+ * Build full context+ */+ private buildContext(type: HookType, partial: Partial<HookContext>): HookContext {+ return {+ executionId: this.generateExecutionId(),+ hookType: type,+ timestamp: Date.now(),+ source: partial.source || 'hook-executor',+ ...partial+ };+ }++ /**+ * Generate execution ID+ */+ private generateExecutionId(): string {+ return `exec-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;+ }++ /**+ * Create timeout error+ */+ private createTimeoutError(hookId: string, hookType: HookType, timeout: number): HookTimeoutError {+ const error = new Error(`Hook ${hookId} timed out after ${timeout}ms`) as HookTimeoutError;+ error.name = 'HookTimeoutError';+ error.hookId = hookId;+ error.hookType = hookType;+ return error;+ }++ /**+ * Delay helper+ */+ private delay(ms: number): Promise<void> {+ return new Promise(resolve => setTimeout(resolve, ms));+ }+}++// Export singleton instance+export const hookExecutor = new HookExecutor();diff --git a/v3/hooks/hook-registry.ts b/v3/hooks/hook-registry.tsnew file mode 100644index 0000000000..b98a20a08f--- /dev/null+++ b/v3/hooks/hook-registry.ts@@ -0,0 +1,385 @@+/**+ * V3 Hook Registry+ * Central registry for hook registration and lookup+ */++import type {+ HookType,+ HookRegistration,+ HookFilter,+ HookContext,+ HookStatistics,+ HookValidationError+} from './types.js';++/**+ * Hook registry for managing hook registrations+ */+export class HookRegistry {+ /** Hooks organized by type */+ private hooksByType: Map<HookType, HookRegistration[]> = new Map();++ /** All hooks by ID for quick lookup */+ private hooksById: Map<string, HookRegistration> = new Map();++ /** Hook statistics */+ private statistics: Map<string, HookStatistics> = new Map();++ /** Tags index for filtering */+ private hooksByTag: Map<string, Set<string>> = new Map();++ /**+ * Register a new hook+ */+ register(registration: HookRegistration): void {+ // Validate registration+ this.validateRegistration(registration);++ const { id, type } = registration;++ // Check for duplicate ID+ if (this.hooksById.has(id)) {+ throw new Error(`Hook with ID '${id}' is already registered`);+ }++ // Initialize type list if needed+ if (!this.hooksByType.has(type)) {+ this.hooksByType.set(type, []);+ }++ // Add to type list, maintaining priority order+ const hookList = this.hooksByType.get(type)!;+ const insertIndex = hookList.findIndex(h => h.priority < registration.priority);++ if (insertIndex === -1) {+ hookList.push(registration);+ } else {+ hookList.splice(insertIndex, 0, registration);+ }++ // Add to ID map+ this.hooksById.set(id, registration);++ // Index tags+ if (registration.tags) {+ for (const tag of registration.tags) {+ if (!this.hooksByTag.has(tag)) {+ this.hooksByTag.set(tag, new Set());+ }+ this.hooksByTag.get(tag)!.add(id);+ }+ }++ // Initialize statistics+ this.statistics.set(id, {+ hookId: id,+ hookType: type,+ totalExecutions: 0,+ successfulExecutions: 0,+ failedExecutions: 0,+ averageDuration: 0,+ p50Duration: 0,+ p95Duration: 0,+ p99Duration: 0,+ cacheHitRate: 0+ });+ }++ /**+ * Unregister a hook by ID+ */+ unregister(hookId: string): boolean {+ const registration = this.hooksById.get(hookId);++ if (!registration) {+ return false;+ }++ // Remove from type list+ const hookList = this.hooksByType.get(registration.type);+ if (hookList) {+ const index = hookList.findIndex(h => h.id === hookId);+ if (index !== -1) {+ hookList.splice(index, 1);+ }++ // Clean up empty type list+ if (hookList.length === 0) {+ this.hooksByType.delete(registration.type);+ }+ }++ // Remove from ID map+ this.hooksById.delete(hookId);++ // Remove from tag index+ if (registration.tags) {+ for (const tag of registration.tags) {+ const tagSet = this.hooksByTag.get(tag);+ if (tagSet) {+ tagSet.delete(hookId);+ if (tagSet.size === 0) {+ this.hooksByTag.delete(tag);+ }+ }+ }+ }++ // Remove statistics+ this.statistics.delete(hookId);++ return true;+ }++ /**+ * Get all hooks for a specific type+ */+ getByType(type: HookType): HookRegistration[] {+ return [...(this.hooksByType.get(type) || [])];+ }++ /**+ * Get hooks matching a filter+ */+ getByFilter(type: HookType, filter: HookFilter, context?: HookContext): HookRegistration[] {+ const hooks = this.getByType(type);++ return hooks.filter(hook => {+ // Skip disabled hooks+ if (!hook.enabled) {+ return false;+ }++ // No filter on hook = matches all+ if (!hook.filter) {+ return true;+ }++ return this.matchesFilter(hook.filter, filter, context);+ });+ }++ /**+ * Get hook by ID+ */+ getById(hookId: string): HookRegistration | undefined {+ return this.hooksById.get(hookId);+ }++ /**+ * Get hooks by tag+ */+ getByTag(tag: string): HookRegistration[] {+ const hookIds = this.hooksByTag.get(tag);+ if (!hookIds) {+ return [];+ }++ return Array.from(hookIds)+ .map(id => this.hooksById.get(id))+ .filter((h): h is HookRegistration => h !== undefined);+ }++ /**+ * Check if hook exists+ */+ has(hookId: string): boolean {+ return this.hooksById.has(hookId);+ }++ /**+ * Set hook enabled state+ */+ setEnabled(hookId: string, enabled: boolean): boolean {+ const hook = this.hooksById.get(hookId);+ if (!hook) {+ return false;+ }++ hook.enabled = enabled;+ return true;+ }++ /**+ * Get all registered hook types+ */+ getTypes(): HookType[] {+ return Array.from(this.hooksByType.keys());+ }++ /**+ * Get all hooks+ */+ getAll(): HookRegistration[] {+ return Array.from(this.hooksById.values());+ }++ /**+ * Get hook count by type+ */+ getCountByType(): Map<HookType, number> {+ const counts = new Map<HookType, number>();+ for (const [type, hooks] of this.hooksByType) {+ counts.set(type, hooks.length);+ }+ return counts;+ }++ /**+ * Get total hook count+ */+ getCount(): number {+ return this.hooksById.size;+ }++ /**+ * Get hook statistics+ */+ getStatistics(hookId?: string): HookStatistics | HookStatistics[] | undefined {+ if (hookId) {+ return this.statistics.get(hookId);+ }+ return Array.from(this.statistics.values());+ }++ /**+ * Update hook statistics+ */+ updateStatistics(+ hookId: string,+ update: Partial<Pick<HookStatistics, 'totalExecutions' | 'successfulExecutions' | 'failedExecutions'>> & {+ duration?: number;+ cacheHit?: boolean;+ }+ ): void {+ const stats = this.statistics.get(hookId);+ if (!stats) return;++ if (update.totalExecutions !== undefined) {+ stats.totalExecutions += update.totalExecutions;+ }++ if (update.successfulExecutions !== undefined) {+ stats.successfulExecutions += update.successfulExecutions;+ }++ if (update.failedExecutions !== undefined) {+ stats.failedExecutions += update.failedExecutions;+ }++ if (update.duration !== undefined) {+ // Update average duration (running average)+ const n = stats.totalExecutions;+ stats.averageDuration = ((stats.averageDuration * (n - 1)) + update.duration) / n;+ }++ stats.lastExecutedAt = Date.now();+ }++ /**+ * Clear all hooks+ */+ clear(): void {+ this.hooksByType.clear();+ this.hooksById.clear();+ this.hooksByTag.clear();+ this.statistics.clear();+ }++ /**+ * Export registry state for persistence+ */+ export(): { hooks: HookRegistration[]; statistics: HookStatistics[] } {+ return {+ hooks: this.getAll().map(h => ({+ ...h,+ // Exclude non-serializable handler+ handler: undefined as any+ })),+ statistics: Array.from(this.statistics.values())+ };+ }++ // ============================================+ // Private Methods+ // ============================================++ /**+ * Validate hook registration+ */+ private validateRegistration(registration: HookRegistration): void {+ if (!registration.id || typeof registration.id !== 'string') {+ throw this.createValidationError('id', 'Hook ID is required and must be a string', registration.id);+ }++ if (!registration.type) {+ throw this.createValidationError('type', 'Hook type is required', registration.type);+ }++ if (typeof registration.handler !== 'function') {+ throw this.createValidationError('handler', 'Hook handler must be a function', typeof registration.handler);+ }++ if (typeof registration.priority !== 'number' || registration.priority < 0) {+ throw this.createValidationError('priority', 'Hook priority must be a non-negative number', registration.priority);+ }++ if (registration.options?.timeout !== undefined && registration.options.timeout <= 0) {+ throw this.createValidationError('options.timeout', 'Timeout must be a positive number', registration.options.timeout);+ }++ if (registration.options?.retries !== undefined && registration.options.retries < 0) {+ throw this.createValidationError('options.retries', 'Retries must be a non-negative number', registration.options.retries);+ }+ }++ /**+ * Check if a hook filter matches the given filter and context+ */+ private matchesFilter(hookFilter: HookFilter, filter: HookFilter, context?: HookContext): boolean {+ // Check agent types+ if (hookFilter.agentTypes && filter.agentTypes) {+ const hasMatch = hookFilter.agentTypes.some(t => filter.agentTypes!.includes(t));+ if (!hasMatch) return false;+ }++ // Check task types+ if (hookFilter.taskTypes && filter.taskTypes) {+ const hasMatch = hookFilter.taskTypes.some(t => filter.taskTypes!.includes(t));+ if (!hasMatch) return false;+ }++ // Check namespaces+ if (hookFilter.namespaces && filter.namespaces) {+ const hasMatch = hookFilter.namespaces.some(n => filter.namespaces!.includes(n));+ if (!hasMatch) return false;+ }++ // Check providers+ if (hookFilter.providers && filter.providers) {+ const hasMatch = hookFilter.providers.some(p => filter.providers!.includes(p));+ if (!hasMatch) return false;+ }++ // Check custom filter+ if (hookFilter.custom && context) {+ if (!hookFilter.custom(context)) return false;+ }++ return true;+ }++ /**+ * Create validation error+ */+ private createValidationError(field: string, message: string, value?: unknown): HookValidationError {+ const error = new Error(message) as HookValidationError;+ error.name = 'HookValidationError';+ error.field = field;+ error.value = value;+ return error;+ }+}++// Export singleton instance+export const hookRegistry = new HookRegistry();diff --git a/v3/hooks/types.ts b/v3/hooks/types.tsnew file mode 100644index 0000000000..5e0c5d34c3--- /dev/null+++ b/v3/hooks/types.ts@@ -0,0 +1,602 @@+/**+ * V3 Hook System Types+ * Comprehensive type definitions for the enhanced hook system+ */++// ============================================+// Core Hook Types+// ============================================++/**+ * All available hook types in V3+ */+export type HookType =+ // Agent lifecycle hooks+ | 'agent:spawn:before'+ | 'agent:spawn:after'+ | 'agent:stop:before'+ | 'agent:stop:after'+ | 'agent:error'+ | 'agent:message'+ | 'agent:state-change'++ // Task hooks+ | 'task:create:before'+ | 'task:create:after'+ | 'task:start:before'+ | 'task:start:after'+ | 'task:complete'+ | 'task:fail'+ | 'task:decompose'+ | 'task:assign'++ // Swarm coordination hooks+ | 'swarm:init:before'+ | 'swarm:init:after'+ | 'swarm:coordinate:before'+ | 'swarm:coordinate:after'+ | 'swarm:consensus:start'+ | 'swarm:consensus:complete'+ | 'swarm:scale'+ | 'swarm:topology-change'++ // Memory hooks+ | 'memory:store:before'+ | 'memory:store:after'+ | 'memory:retrieve:before'+ | 'memory:retrieve:after'+ | 'memory:search:before'+ | 'memory:search:after'+ | 'memory:delete'+ | 'memory:sync'++ // Performance hooks+ | 'performance:benchmark:start'+ | 'performance:benchmark:end'+ | 'performance:metric'+ | 'performance:threshold-exceeded'+ | 'performance:optimize'++ // Learning/SONA hooks+ | 'learning:pattern:detected'+ | 'learning:pattern:stored'+ | 'learning:adapt'+ | 'learning:train:start'+ | 'learning:train:complete'+ | 'learning:feedback'++ // Session hooks+ | 'session:start'+ | 'session:end'+ | 'session:restore'+ | 'session:save'++ // MCP hooks+ | 'mcp:tool:call:before'+ | 'mcp:tool:call:after'+ | 'mcp:server:start'+ | 'mcp:server:stop'++ // General hooks+ | 'error'+ | 'warning'+ | 'log'+ | 'custom';++/**+ * Hook priority levels+ */+export type HookPriority = 'critical' | 'high' | 'normal' | 'low' | 'background';++/**+ * Hook execution mode+ */+export type HookExecutionMode = 'sync' | 'async' | 'parallel' | 'sequential';++// ============================================+// Hook Context and Payload+// ============================================++/**+ * Base context available to all hooks+ */+export interface HookContext {+ /** Unique execution ID */+ executionId: string;+ /** Hook type being executed */+ hookType: HookType;+ /** Timestamp of hook execution */+ timestamp: number;+ /** Source of the hook trigger */+ source: string;+ /** Current session ID if available */+ sessionId?: string;+ /** Metadata from the trigger */+ metadata?: Record<string, unknown>;+ /** Parent context for nested hooks */+ parent?: HookContext;+}++/**+ * Agent-specific context+ */+export interface AgentHookContext extends HookContext {+ agentId: string;+ agentType: string;+ agentName: string;+ provider?: string;+ model?: string;+ capabilities?: string[];+}++/**+ * Task-specific context+ */+export interface TaskHookContext extends HookContext {+ taskId: string;+ taskDescription: string;+ taskPriority?: 'high' | 'medium' | 'low';+ assignedAgent?: string;+ dependencies?: string[];+ estimatedDuration?: number;+}++/**+ * Swarm-specific context+ */+export interface SwarmHookContext extends HookContext {+ swarmId: string;+ topology: string;+ agentCount: number;+ strategy: string;+ coordinatorId?: string;+}++/**+ * Memory-specific context+ */+export interface MemoryHookContext extends HookContext {+ namespace: string;+ key?: string;+ operation: 'store' | 'retrieve' | 'search' | 'delete' | 'sync';+ backend: string;+ isVector?: boolean;+}++/**+ * Performance-specific context+ */+export interface PerformanceHookContext extends HookContext {+ operation: string;+ duration?: number;+ metrics?: Record<string, number>;+ threshold?: number;+}++/**+ * Learning-specific context+ */+export interface LearningHookContext extends HookContext {+ patternId?: string;+ patternType?: string;+ confidence?: number;+ source?: string;+ rewardSignal?: number;+}++/**+ * Generic hook payload+ */+export interface HookPayload<T = unknown> {+ data: T;+ context: HookContext;+ modifiable?: boolean;+}++// ============================================+// Hook Handler Types+// ============================================++/**+ * Result returned by hook handlers+ */+export interface HookResult<T = unknown> {+ /** Whether to continue execution */+ continue: boolean;+ /** Whether the payload was modified */+ modified: boolean;+ /** Modified payload data */+ data?: T;+ /** Error if any */+ error?: Error;+ /** Side effects to process */+ sideEffects?: SideEffect[];+ /** Metrics from this hook execution */+ metrics?: HookMetrics;+ /** Message for logging */+ message?: string;+}++/**+ * Hook handler function signature+ */+export type HookHandler<TPayload = unknown, TResult = unknown> = (+ payload: HookPayload<TPayload>,+ context: HookContext+) => Promise<HookResult<TResult>> | HookResult<TResult>;++/**+ * Async hook handler+ */+export type AsyncHookHandler<TPayload = unknown, TResult = unknown> = (+ payload: HookPayload<TPayload>,+ context: HookContext+) => Promise<HookResult<TResult>>;++/**+ * Sync hook handler+ */+export type SyncHookHandler<TPayload = unknown, TResult = unknown> = (+ payload: HookPayload<TPayload>,+ context: HookContext+) => HookResult<TResult>;++// ============================================+// Hook Registration+// ============================================++/**+ * Hook registration configuration+ */+export interface HookRegistration<TPayload = unknown, TResult = unknown> {+ /** Unique hook ID */+ id: string;+ /** Hook type to listen for */+ type: HookType;+ /** Hook name for display */+ name: string;+ /** Hook description */+ description?: string;+ /** Handler function */+ handler: HookHandler<TPayload, TResult>;+ /** Execution priority (higher = earlier) */+ priority: number;+ /** Priority level for readability */+ priorityLevel?: HookPriority;+ /** Whether hook is enabled */+ enabled: boolean;+ /** Execution mode */+ mode?: HookExecutionMode;+ /** Filter conditions */+ filter?: HookFilter;+ /** Hook options */+ options?: HookOptions;+ /** Tags for categorization */+ tags?: string[];+ /** Version requirement */+ version?: string;+}++/**+ * Hook filter conditions+ */+export interface HookFilter {+ /** Filter by agent types */+ agentTypes?: string[];+ /** Filter by task types */+ taskTypes?: string[];+ /** Filter by namespaces */+ namespaces?: string[];+ /** Filter by providers */+ providers?: string[];+ /** Filter by patterns */+ patterns?: RegExp[];+ /** Custom filter function */+ custom?: (context: HookContext) => boolean;+}++/**+ * Hook options+ */+export interface HookOptions {+ /** Timeout in milliseconds */+ timeout?: number;+ /** Number of retries on failure */+ retries?: number;+ /** Retry delay in milliseconds */+ retryDelay?: number;+ /** Whether to run in isolated context */+ isolated?: boolean;+ /** Cache configuration */+ cache?: {+ enabled: boolean;+ ttl: number;+ key: (payload: HookPayload) => string;+ };+ /** Error handler */+ onError?: (error: Error, context: HookContext) => void;+ /** Fallback handler on failure */+ fallback?: HookHandler;+ /** Dependencies on other hooks */+ dependsOn?: string[];+ /** Abort signal for cancellation */+ signal?: AbortSignal;+}++// ============================================+// Side Effects+// ============================================++/**+ * Side effect types+ */+export type SideEffectType =+ | 'memory'+ | 'neural'+ | 'metric'+ | 'notification'+ | 'log'+ | 'event'+ | 'spawn-agent'+ | 'create-task'+ | 'update-state'+ | 'external-call';++/**+ * Side effect definition+ */+export interface SideEffect {+ type: SideEffectType;+ action: string;+ data: Record<string, unknown>;+ priority?: HookPriority;+ async?: boolean;+}++// ============================================+// Hook Pipeline+// ============================================++/**+ * Pipeline stage+ */+export interface PipelineStage {+ name: string;+ hooks: HookRegistration[];+ parallel?: boolean;+ condition?: (context: HookContext) => boolean;+ transform?: (result: HookResult) => HookResult;+ onError?: 'skip' | 'abort' | 'retry';+}++/**+ * Hook pipeline configuration+ */+export interface HookPipeline {+ id: string;+ name: string;+ description?: string;+ stages: PipelineStage[];+ errorStrategy: 'fail-fast' | 'continue' | 'rollback';+ metrics: PipelineMetrics;+}++/**+ * Pipeline metrics+ */+export interface PipelineMetrics {+ executions: number;+ avgDuration: number;+ errorRate: number;+ throughput: number;+ lastExecution?: number;+}++// ============================================+// Hook Metrics+// ============================================++/**+ * Metrics from hook execution+ */+export interface HookMetrics {+ /** Execution duration in ms */+ duration: number;+ /** Whether result was cached */+ cached?: boolean;+ /** Memory used */+ memoryUsed?: number;+ /** Tokens processed */+ tokensProcessed?: number;+ /** Custom metrics */+ custom?: Record<string, number>;+}++/**+ * Aggregated hook statistics+ */+export interface HookStatistics {+ hookId: string;+ hookType: HookType;+ totalExecutions: number;+ successfulExecutions: number;+ failedExecutions: number;+ averageDuration: number;+ p50Duration: number;+ p95Duration: number;+ p99Duration: number;+ cacheHitRate: number;+ lastExecutedAt?: number;+ errorTypes?: Record<string, number>;+}++// ============================================+// Hook Events+// ============================================++/**+ * Hook event types+ */+export type HookEventType =+ | 'hook:registered'+ | 'hook:unregistered'+ | 'hook:executing'+ | 'hook:executed'+ | 'hook:error'+ | 'hook:timeout'+ | 'hook:retry'+ | 'pipeline:start'+ | 'pipeline:complete'+ | 'pipeline:error';++/**+ * Hook event+ */+export interface HookEvent {+ type: HookEventType;+ hookId?: string;+ hookType?: HookType;+ pipelineId?: string;+ timestamp: number;+ data?: unknown;+ error?: Error;+}++// ============================================+// Hook Manager Interface+// ============================================++/**+ * Hook manager interface+ */+export interface IHookManager {+ /** Register a hook */+ register(registration: HookRegistration): void;++ /** Unregister a hook */+ unregister(hookId: string): void;++ /** Execute hooks for a type */+ execute<T>(type: HookType, payload: T, context?: Partial<HookContext>): Promise<HookResult<T>[]>;++ /** Get hooks by type */+ getHooks(type: HookType): HookRegistration[];++ /** Get hook by ID */+ getHook(hookId: string): HookRegistration | undefined;++ /** Enable/disable hook */+ setEnabled(hookId: string, enabled: boolean): void;++ /** Get hook statistics */+ getStatistics(hookId?: string): HookStatistics | HookStatistics[];++ /** Clear all hooks */+ clear(): void;++ /** Create a pipeline */+ createPipeline(config: Partial<HookPipeline>): HookPipeline;++ /** Execute a pipeline */+ executePipeline(pipelineId: string, payload: unknown, context?: Partial<HookContext>): Promise<HookResult[]>;+}++// ============================================+// Hook Composition Types+// ============================================++/**+ * Hook chain configuration+ */+export interface HookChain {+ id: string;+ name: string;+ hooks: HookRegistration[];+ mode: 'serial' | 'waterfall' | 'parallel' | 'race';+ stopOnError?: boolean;+ timeout?: number;+}++/**+ * Hook composition result+ */+export interface CompositionResult<T = unknown> {+ success: boolean;+ results: HookResult<T>[];+ aggregatedData?: T;+ errors: Error[];+ duration: number;+ hookCount: number;+}++/**+ * Hook combinator functions+ */+export interface HookCombinators {+ /** Run hooks in sequence, passing result to next */+ pipe<T>(...handlers: HookHandler<T>[]): HookHandler<T>;++ /** Run hooks in parallel */+ parallel<T>(...handlers: HookHandler<T>[]): HookHandler<T>;++ /** Run first successful hook */+ race<T>(...handlers: HookHandler<T>[]): HookHandler<T>;++ /** Run hooks and merge results */+ merge<T>(...handlers: HookHandler<T>[]): HookHandler<T>;++ /** Apply condition before running hook */+ when<T>(condition: (ctx: HookContext) => boolean, handler: HookHandler<T>): HookHandler<T>;++ /** Retry hook on failure */+ retry<T>(handler: HookHandler<T>, attempts: number, delay?: number): HookHandler<T>;++ /** Add timeout to hook */+ timeout<T>(handler: HookHandler<T>, ms: number): HookHandler<T>;++ /** Cache hook results */+ cache<T>(handler: HookHandler<T>, ttl: number, keyFn?: (payload: HookPayload<T>) => string): HookHandler<T>;+}++// ============================================+// Error Types+// ============================================++/**+ * Hook error+ */+export class HookError extends Error {+ constructor(+ message: string,+ public hookId: string,+ public hookType: HookType,+ public cause?: Error+ ) {+ super(message);+ this.name = 'HookError';+ }+}++/**+ * Hook timeout error+ */+export class HookTimeoutError extends HookError {+ constructor(hookId: string, hookType: HookType, timeout: number) {+ super(`Hook ${hookId} timed out after ${timeout}ms`, hookId, hookType);+ this.name = 'HookTimeoutError';+ }+}++/**+ * Hook validation error+ */+export class HookValidationError extends Error {+ constructor(+ message: string,+ public field: string,+ public value?: unknown+ ) {+ super(message);+ this.name = 'HookValidationError';+ }+}diff --git a/v3/integration/agentic-flow-bridge.ts b/v3/integration/agentic-flow-bridge.tsindex de4cc4a356..b0825c7841 100644--- a/v3/integration/agentic-flow-bridge.ts+++ b/v3/integration/agentic-flow-bridge.ts@@ -545,12 +545,35 @@ export class AgenticFlowBridge extends EventEmitter {this.sona = null;this.attention = null;this.sdk = null;+ this.agenticFlowCore = null;+ this.agenticFlowAvailable = false;this.initialized = false;this.componentHealth.clear();this.emit('shutdown');}+ /**+ * Check if agentic-flow@alpha is connected and available for delegation+ *+ * When true, components can delegate to agentic-flow for optimized+ * implementations (per ADR-001).+ */+ isAgenticFlowConnected(): boolean {+ return this.agenticFlowAvailable && this.agenticFlowCore !== null;+ }++ /**+ * Get the agentic-flow core instance for direct access+ *+ * Returns null if agentic-flow is not available.+ * Prefer using getSONAAdapter() or getAttentionCoordinator() which+ * handle delegation automatically.+ */+ getAgenticFlowCore(): AgenticFlowCore | null {+ return this.agenticFlowCore;+ }+// ===== Private Methods =====private mergeConfig(config: Partial<IntegrationConfig>): IntegrationConfig {diff --git a/v3/package-lock.json b/v3/package-lock.jsonnew file mode 100644index 0000000000..2543d3ed47--- /dev/null+++ b/v3/package-lock.json@@ -0,0 +1,2696 @@+{+ "name": "@claude-flow/v3",+ "version": "3.0.0-alpha.1",+ "lockfileVersion": 3,+ "requires": true,+ "packages": {+ "": {+ "name": "@claude-flow/v3",+ "version": "3.0.0-alpha.1",+ "dependencies": {+ "bcrypt": "^5.1.1",+ "zod": "^3.22.0"+ },+ "devDependencies": {+ "@types/bcrypt": "^5.0.2",+ "@types/node": "^20.0.0",+ "@vitest/coverage-v8": "^1.0.0",+ "typescript": "^5.3.0",+ "vitest": "^1.0.0"+ },+ "engines": {+ "node": ">=20.0.0"+ }+ },+ "node_modules/@ampproject/remapping": {+ "version": "2.3.0",+ "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",+ "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==",+ "dev": true,+ "license": "Apache-2.0",+ "dependencies": {+ "@jridgewell/gen-mapping": "^0.3.5",+ "@jridgewell/trace-mapping": "^0.3.24"+ },+ "engines": {+ "node": ">=6.0.0"+ }+ },+ "node_modules/@babel/helper-string-parser": {+ "version": "7.27.1",+ "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",+ "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=6.9.0"+ }+ },+ "node_modules/@babel/helper-validator-identifier": {+ "version": "7.28.5",+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",+ "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=6.9.0"+ }+ },+ "node_modules/@babel/parser": {+ "version": "7.28.5",+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz",+ "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@babel/types": "^7.28.5"+ },+ "bin": {+ "parser": "bin/babel-parser.js"+ },+ "engines": {+ "node": ">=6.0.0"+ }+ },+ "node_modules/@babel/types": {+ "version": "7.28.5",+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz",+ "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@babel/helper-string-parser": "^7.27.1",+ "@babel/helper-validator-identifier": "^7.28.5"+ },+ "engines": {+ "node": ">=6.9.0"+ }+ },+ "node_modules/@bcoe/v8-coverage": {+ "version": "0.2.3",+ "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz",+ "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/@esbuild/aix-ppc64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",+ "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",+ "cpu": [+ "ppc64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "aix"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/android-arm": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",+ "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "android"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/android-arm64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",+ "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "android"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/android-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",+ "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "android"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/darwin-arm64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",+ "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/darwin-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",+ "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/freebsd-arm64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",+ "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "freebsd"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/freebsd-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",+ "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "freebsd"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-arm": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",+ "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-arm64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",+ "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-ia32": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",+ "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",+ "cpu": [+ "ia32"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-loong64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",+ "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",+ "cpu": [+ "loong64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-mips64el": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",+ "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",+ "cpu": [+ "mips64el"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-ppc64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",+ "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",+ "cpu": [+ "ppc64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-riscv64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",+ "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",+ "cpu": [+ "riscv64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-s390x": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",+ "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",+ "cpu": [+ "s390x"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/linux-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",+ "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/netbsd-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",+ "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "netbsd"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/openbsd-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",+ "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "openbsd"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/sunos-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",+ "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "sunos"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/win32-arm64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",+ "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/win32-ia32": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",+ "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",+ "cpu": [+ "ia32"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@esbuild/win32-x64": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",+ "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ],+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/@istanbuljs/schema": {+ "version": "0.1.3",+ "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz",+ "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/@jest/schemas": {+ "version": "29.6.3",+ "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz",+ "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@sinclair/typebox": "^0.27.8"+ },+ "engines": {+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"+ }+ },+ "node_modules/@jridgewell/gen-mapping": {+ "version": "0.3.13",+ "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",+ "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@jridgewell/sourcemap-codec": "^1.5.0",+ "@jridgewell/trace-mapping": "^0.3.24"+ }+ },+ "node_modules/@jridgewell/resolve-uri": {+ "version": "3.1.2",+ "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",+ "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=6.0.0"+ }+ },+ "node_modules/@jridgewell/sourcemap-codec": {+ "version": "1.5.5",+ "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",+ "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/@jridgewell/trace-mapping": {+ "version": "0.3.31",+ "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",+ "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@jridgewell/resolve-uri": "^3.1.0",+ "@jridgewell/sourcemap-codec": "^1.4.14"+ }+ },+ "node_modules/@mapbox/node-pre-gyp": {+ "version": "1.0.11",+ "resolved": "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.11.tgz",+ "integrity": "sha512-Yhlar6v9WQgUp/He7BdgzOz8lqMQ8sU+jkCq7Wx8Myc5YFJLbEe7lgui/V7G1qB1DJykHSGwreceSaD60Y0PUQ==",+ "license": "BSD-3-Clause",+ "dependencies": {+ "detect-libc": "^2.0.0",+ "https-proxy-agent": "^5.0.0",+ "make-dir": "^3.1.0",+ "node-fetch": "^2.6.7",+ "nopt": "^5.0.0",+ "npmlog": "^5.0.1",+ "rimraf": "^3.0.2",+ "semver": "^7.3.5",+ "tar": "^6.1.11"+ },+ "bin": {+ "node-pre-gyp": "bin/node-pre-gyp"+ }+ },+ "node_modules/@rollup/rollup-android-arm-eabi": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.54.0.tgz",+ "integrity": "sha512-OywsdRHrFvCdvsewAInDKCNyR3laPA2mc9bRYJ6LBp5IyvF3fvXbbNR0bSzHlZVFtn6E0xw2oZlyjg4rKCVcng==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "android"+ ]+ },+ "node_modules/@rollup/rollup-android-arm64": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.54.0.tgz",+ "integrity": "sha512-Skx39Uv+u7H224Af+bDgNinitlmHyQX1K/atIA32JP3JQw6hVODX5tkbi2zof/E69M1qH2UoN3Xdxgs90mmNYw==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "android"+ ]+ },+ "node_modules/@rollup/rollup-darwin-arm64": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.54.0.tgz",+ "integrity": "sha512-k43D4qta/+6Fq+nCDhhv9yP2HdeKeP56QrUUTW7E6PhZP1US6NDqpJj4MY0jBHlJivVJD5P8NxrjuobZBJTCRw==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ]+ },+ "node_modules/@rollup/rollup-darwin-x64": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.54.0.tgz",+ "integrity": "sha512-cOo7biqwkpawslEfox5Vs8/qj83M/aZCSSNIWpVzfU2CYHa2G3P1UN5WF01RdTHSgCkri7XOlTdtk17BezlV3A==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ]+ },+ "node_modules/@rollup/rollup-freebsd-arm64": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.54.0.tgz",+ "integrity": "sha512-miSvuFkmvFbgJ1BevMa4CPCFt5MPGw094knM64W9I0giUIMMmRYcGW/JWZDriaw/k1kOBtsWh1z6nIFV1vPNtA==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "freebsd"+ ]+ },+ "node_modules/@rollup/rollup-freebsd-x64": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.54.0.tgz",+ "integrity": "sha512-KGXIs55+b/ZfZsq9aR026tmr/+7tq6VG6MsnrvF4H8VhwflTIuYh+LFUlIsRdQSgrgmtM3fVATzEAj4hBQlaqQ==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "freebsd"+ ]+ },+ "node_modules/@rollup/rollup-linux-arm-gnueabihf": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.54.0.tgz",+ "integrity": "sha512-EHMUcDwhtdRGlXZsGSIuXSYwD5kOT9NVnx9sqzYiwAc91wfYOE1g1djOEDseZJKKqtHAHGwnGPQu3kytmfaXLQ==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-arm-musleabihf": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.54.0.tgz",+ "integrity": "sha512-+pBrqEjaakN2ySv5RVrj/qLytYhPKEUwk+e3SFU5jTLHIcAtqh2rLrd/OkbNuHJpsBgxsD8ccJt5ga/SeG0JmA==",+ "cpu": [+ "arm"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-arm64-gnu": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.54.0.tgz",+ "integrity": "sha512-NSqc7rE9wuUaRBsBp5ckQ5CVz5aIRKCwsoa6WMF7G01sX3/qHUw/z4pv+D+ahL1EIKy6Enpcnz1RY8pf7bjwng==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-arm64-musl": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.54.0.tgz",+ "integrity": "sha512-gr5vDbg3Bakga5kbdpqx81m2n9IX8M6gIMlQQIXiLTNeQW6CucvuInJ91EuCJ/JYvc+rcLLsDFcfAD1K7fMofg==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-loong64-gnu": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.54.0.tgz",+ "integrity": "sha512-gsrtB1NA3ZYj2vq0Rzkylo9ylCtW/PhpLEivlgWe0bpgtX5+9j9EZa0wtZiCjgu6zmSeZWyI/e2YRX1URozpIw==",+ "cpu": [+ "loong64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-ppc64-gnu": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.54.0.tgz",+ "integrity": "sha512-y3qNOfTBStmFNq+t4s7Tmc9hW2ENtPg8FeUD/VShI7rKxNW7O4fFeaYbMsd3tpFlIg1Q8IapFgy7Q9i2BqeBvA==",+ "cpu": [+ "ppc64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-riscv64-gnu": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.54.0.tgz",+ "integrity": "sha512-89sepv7h2lIVPsFma8iwmccN7Yjjtgz0Rj/Ou6fEqg3HDhpCa+Et+YSufy27i6b0Wav69Qv4WBNl3Rs6pwhebQ==",+ "cpu": [+ "riscv64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-riscv64-musl": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.54.0.tgz",+ "integrity": "sha512-ZcU77ieh0M2Q8Ur7D5X7KvK+UxbXeDHwiOt/CPSBTI1fBmeDMivW0dPkdqkT4rOgDjrDDBUed9x4EgraIKoR2A==",+ "cpu": [+ "riscv64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-s390x-gnu": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.54.0.tgz",+ "integrity": "sha512-2AdWy5RdDF5+4YfG/YesGDDtbyJlC9LHmL6rZw6FurBJ5n4vFGupsOBGfwMRjBYH7qRQowT8D/U4LoSvVwOhSQ==",+ "cpu": [+ "s390x"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-x64-gnu": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.54.0.tgz",+ "integrity": "sha512-WGt5J8Ij/rvyqpFexxk3ffKqqbLf9AqrTBbWDk7ApGUzaIs6V+s2s84kAxklFwmMF/vBNGrVdYgbblCOFFezMQ==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-linux-x64-musl": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.54.0.tgz",+ "integrity": "sha512-JzQmb38ATzHjxlPHuTH6tE7ojnMKM2kYNzt44LO/jJi8BpceEC8QuXYA908n8r3CNuG/B3BV8VR3Hi1rYtmPiw==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "linux"+ ]+ },+ "node_modules/@rollup/rollup-openharmony-arm64": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.54.0.tgz",+ "integrity": "sha512-huT3fd0iC7jigGh7n3q/+lfPcXxBi+om/Rs3yiFxjvSxbSB6aohDFXbWvlspaqjeOh+hx7DDHS+5Es5qRkWkZg==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "openharmony"+ ]+ },+ "node_modules/@rollup/rollup-win32-arm64-msvc": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.54.0.tgz",+ "integrity": "sha512-c2V0W1bsKIKfbLMBu/WGBz6Yci8nJ/ZJdheE0EwB73N3MvHYKiKGs3mVilX4Gs70eGeDaMqEob25Tw2Gb9Nqyw==",+ "cpu": [+ "arm64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ]+ },+ "node_modules/@rollup/rollup-win32-ia32-msvc": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.54.0.tgz",+ "integrity": "sha512-woEHgqQqDCkAzrDhvDipnSirm5vxUXtSKDYTVpZG3nUdW/VVB5VdCYA2iReSj/u3yCZzXID4kuKG7OynPnB3WQ==",+ "cpu": [+ "ia32"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ]+ },+ "node_modules/@rollup/rollup-win32-x64-gnu": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.54.0.tgz",+ "integrity": "sha512-dzAc53LOuFvHwbCEOS0rPbXp6SIhAf2txMP5p6mGyOXXw5mWY8NGGbPMPrs4P1WItkfApDathBj/NzMLUZ9rtQ==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ]+ },+ "node_modules/@rollup/rollup-win32-x64-msvc": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.54.0.tgz",+ "integrity": "sha512-hYT5d3YNdSh3mbCU1gwQyPgQd3T2ne0A3KG8KSBdav5TiBg6eInVmV+TeR5uHufiIgSFg0XsOWGW5/RhNcSvPg==",+ "cpu": [+ "x64"+ ],+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "win32"+ ]+ },+ "node_modules/@sinclair/typebox": {+ "version": "0.27.8",+ "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",+ "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/@types/bcrypt": {+ "version": "5.0.2",+ "resolved": "https://registry.npmjs.org/@types/bcrypt/-/bcrypt-5.0.2.tgz",+ "integrity": "sha512-6atioO8Y75fNcbmj0G7UjI9lXN2pQ/IGJ2FWT4a/btd0Lk9lQalHLKhkgKVZ3r+spnmWUKfbMi1GEe9wyHQfNQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@types/node": "*"+ }+ },+ "node_modules/@types/estree": {+ "version": "1.0.8",+ "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",+ "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/@types/node": {+ "version": "20.19.27",+ "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.27.tgz",+ "integrity": "sha512-N2clP5pJhB2YnZJ3PIHFk5RkygRX5WO/5f0WC08tp0wd+sv0rsJk3MqWn3CbNmT2J505a5336jaQj4ph1AdMug==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "undici-types": "~6.21.0"+ }+ },+ "node_modules/@vitest/coverage-v8": {+ "version": "1.6.1",+ "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-1.6.1.tgz",+ "integrity": "sha512-6YeRZwuO4oTGKxD3bijok756oktHSIm3eczVVzNe3scqzuhLwltIF3S9ZL/vwOVIpURmU6SnZhziXXAfw8/Qlw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@ampproject/remapping": "^2.2.1",+ "@bcoe/v8-coverage": "^0.2.3",+ "debug": "^4.3.4",+ "istanbul-lib-coverage": "^3.2.2",+ "istanbul-lib-report": "^3.0.1",+ "istanbul-lib-source-maps": "^5.0.4",+ "istanbul-reports": "^3.1.6",+ "magic-string": "^0.30.5",+ "magicast": "^0.3.3",+ "picocolors": "^1.0.0",+ "std-env": "^3.5.0",+ "strip-literal": "^2.0.0",+ "test-exclude": "^6.0.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ },+ "peerDependencies": {+ "vitest": "1.6.1"+ }+ },+ "node_modules/@vitest/expect": {+ "version": "1.6.1",+ "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.6.1.tgz",+ "integrity": "sha512-jXL+9+ZNIJKruofqXuuTClf44eSpcHlgj3CiuNihUF3Ioujtmc0zIa3UJOW5RjDK1YLBJZnWBlPuqhYycLioog==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@vitest/spy": "1.6.1",+ "@vitest/utils": "1.6.1",+ "chai": "^4.3.10"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/runner": {+ "version": "1.6.1",+ "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-1.6.1.tgz",+ "integrity": "sha512-3nSnYXkVkf3mXFfE7vVyPmi3Sazhb/2cfZGGs0JRzFsPFvAMBEcrweV1V1GsrstdXeKCTXlJbvnQwGWgEIHmOA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@vitest/utils": "1.6.1",+ "p-limit": "^5.0.0",+ "pathe": "^1.1.1"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/snapshot": {+ "version": "1.6.1",+ "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-1.6.1.tgz",+ "integrity": "sha512-WvidQuWAzU2p95u8GAKlRMqMyN1yOJkGHnx3M1PL9Raf7AQ1kwLKg04ADlCa3+OXUZE7BceOhVZiuWAbzCKcUQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "magic-string": "^0.30.5",+ "pathe": "^1.1.1",+ "pretty-format": "^29.7.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/spy": {+ "version": "1.6.1",+ "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-1.6.1.tgz",+ "integrity": "sha512-MGcMmpGkZebsMZhbQKkAf9CX5zGvjkBTqf8Zx3ApYWXr3wG+QvEu2eXWfnIIWYSJExIp4V9FCKDEeygzkYrXMw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "tinyspy": "^2.2.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/@vitest/utils": {+ "version": "1.6.1",+ "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-1.6.1.tgz",+ "integrity": "sha512-jOrrUvXM4Av9ZWiG1EajNto0u96kWAhJ1LmPmJhXXQx/32MecEKd10pOLYgS2BQx1TgkGhloPU1ArDW2vvaY6g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "diff-sequences": "^29.6.3",+ "estree-walker": "^3.0.3",+ "loupe": "^2.3.7",+ "pretty-format": "^29.7.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/abbrev": {+ "version": "1.1.1",+ "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",+ "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",+ "license": "ISC"+ },+ "node_modules/acorn": {+ "version": "8.15.0",+ "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",+ "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",+ "dev": true,+ "license": "MIT",+ "bin": {+ "acorn": "bin/acorn"+ },+ "engines": {+ "node": ">=0.4.0"+ }+ },+ "node_modules/acorn-walk": {+ "version": "8.3.4",+ "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz",+ "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "acorn": "^8.11.0"+ },+ "engines": {+ "node": ">=0.4.0"+ }+ },+ "node_modules/agent-base": {+ "version": "6.0.2",+ "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",+ "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",+ "license": "MIT",+ "dependencies": {+ "debug": "4"+ },+ "engines": {+ "node": ">= 6.0.0"+ }+ },+ "node_modules/ansi-regex": {+ "version": "5.0.1",+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",+ "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/ansi-styles": {+ "version": "5.2.0",+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",+ "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=10"+ },+ "funding": {+ "url": "https://github.com/chalk/ansi-styles?sponsor=1"+ }+ },+ "node_modules/aproba": {+ "version": "2.1.0",+ "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.1.0.tgz",+ "integrity": "sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew==",+ "license": "ISC"+ },+ "node_modules/are-we-there-yet": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz",+ "integrity": "sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==",+ "deprecated": "This package is no longer supported.",+ "license": "ISC",+ "dependencies": {+ "delegates": "^1.0.0",+ "readable-stream": "^3.6.0"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/assertion-error": {+ "version": "1.1.0",+ "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz",+ "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": "*"+ }+ },+ "node_modules/balanced-match": {+ "version": "1.0.2",+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",+ "license": "MIT"+ },+ "node_modules/bcrypt": {+ "version": "5.1.1",+ "resolved": "https://registry.npmjs.org/bcrypt/-/bcrypt-5.1.1.tgz",+ "integrity": "sha512-AGBHOG5hPYZ5Xl9KXzU5iKq9516yEmvCKDg3ecP5kX2aB6UqTeXZxk2ELnDgDm6BQSMlLt9rDB4LoSMx0rYwww==",+ "hasInstallScript": true,+ "license": "MIT",+ "dependencies": {+ "@mapbox/node-pre-gyp": "^1.0.11",+ "node-addon-api": "^5.0.0"+ },+ "engines": {+ "node": ">= 10.0.0"+ }+ },+ "node_modules/brace-expansion": {+ "version": "1.1.12",+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",+ "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",+ "license": "MIT",+ "dependencies": {+ "balanced-match": "^1.0.0",+ "concat-map": "0.0.1"+ }+ },+ "node_modules/cac": {+ "version": "6.7.14",+ "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",+ "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/chai": {+ "version": "4.5.0",+ "resolved": "https://registry.npmjs.org/chai/-/chai-4.5.0.tgz",+ "integrity": "sha512-RITGBfijLkBddZvnn8jdqoTypxvqbOLYQkGGxXzeFjVHvudaPw0HNFD9x928/eUwYWd2dPCugVqspGALTZZQKw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "assertion-error": "^1.1.0",+ "check-error": "^1.0.3",+ "deep-eql": "^4.1.3",+ "get-func-name": "^2.0.2",+ "loupe": "^2.3.6",+ "pathval": "^1.1.1",+ "type-detect": "^4.1.0"+ },+ "engines": {+ "node": ">=4"+ }+ },+ "node_modules/check-error": {+ "version": "1.0.3",+ "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.3.tgz",+ "integrity": "sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "get-func-name": "^2.0.2"+ },+ "engines": {+ "node": "*"+ }+ },+ "node_modules/chownr": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz",+ "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==",+ "license": "ISC",+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/color-support": {+ "version": "1.1.3",+ "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",+ "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==",+ "license": "ISC",+ "bin": {+ "color-support": "bin.js"+ }+ },+ "node_modules/concat-map": {+ "version": "0.0.1",+ "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",+ "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",+ "license": "MIT"+ },+ "node_modules/confbox": {+ "version": "0.1.8",+ "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz",+ "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/console-control-strings": {+ "version": "1.1.0",+ "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz",+ "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==",+ "license": "ISC"+ },+ "node_modules/cross-spawn": {+ "version": "7.0.6",+ "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",+ "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "path-key": "^3.1.0",+ "shebang-command": "^2.0.0",+ "which": "^2.0.1"+ },+ "engines": {+ "node": ">= 8"+ }+ },+ "node_modules/debug": {+ "version": "4.4.3",+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",+ "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",+ "license": "MIT",+ "dependencies": {+ "ms": "^2.1.3"+ },+ "engines": {+ "node": ">=6.0"+ },+ "peerDependenciesMeta": {+ "supports-color": {+ "optional": true+ }+ }+ },+ "node_modules/deep-eql": {+ "version": "4.1.4",+ "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.4.tgz",+ "integrity": "sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "type-detect": "^4.0.0"+ },+ "engines": {+ "node": ">=6"+ }+ },+ "node_modules/delegates": {+ "version": "1.0.0",+ "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz",+ "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==",+ "license": "MIT"+ },+ "node_modules/detect-libc": {+ "version": "2.1.2",+ "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",+ "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",+ "license": "Apache-2.0",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/diff-sequences": {+ "version": "29.6.3",+ "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.6.3.tgz",+ "integrity": "sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"+ }+ },+ "node_modules/emoji-regex": {+ "version": "8.0.0",+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",+ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",+ "license": "MIT"+ },+ "node_modules/esbuild": {+ "version": "0.21.5",+ "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",+ "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",+ "dev": true,+ "hasInstallScript": true,+ "license": "MIT",+ "bin": {+ "esbuild": "bin/esbuild"+ },+ "engines": {+ "node": ">=12"+ },+ "optionalDependencies": {+ "@esbuild/aix-ppc64": "0.21.5",+ "@esbuild/android-arm": "0.21.5",+ "@esbuild/android-arm64": "0.21.5",+ "@esbuild/android-x64": "0.21.5",+ "@esbuild/darwin-arm64": "0.21.5",+ "@esbuild/darwin-x64": "0.21.5",+ "@esbuild/freebsd-arm64": "0.21.5",+ "@esbuild/freebsd-x64": "0.21.5",+ "@esbuild/linux-arm": "0.21.5",+ "@esbuild/linux-arm64": "0.21.5",+ "@esbuild/linux-ia32": "0.21.5",+ "@esbuild/linux-loong64": "0.21.5",+ "@esbuild/linux-mips64el": "0.21.5",+ "@esbuild/linux-ppc64": "0.21.5",+ "@esbuild/linux-riscv64": "0.21.5",+ "@esbuild/linux-s390x": "0.21.5",+ "@esbuild/linux-x64": "0.21.5",+ "@esbuild/netbsd-x64": "0.21.5",+ "@esbuild/openbsd-x64": "0.21.5",+ "@esbuild/sunos-x64": "0.21.5",+ "@esbuild/win32-arm64": "0.21.5",+ "@esbuild/win32-ia32": "0.21.5",+ "@esbuild/win32-x64": "0.21.5"+ }+ },+ "node_modules/estree-walker": {+ "version": "3.0.3",+ "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",+ "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@types/estree": "^1.0.0"+ }+ },+ "node_modules/execa": {+ "version": "8.0.1",+ "resolved": "https://registry.npmjs.org/execa/-/execa-8.0.1.tgz",+ "integrity": "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "cross-spawn": "^7.0.3",+ "get-stream": "^8.0.1",+ "human-signals": "^5.0.0",+ "is-stream": "^3.0.0",+ "merge-stream": "^2.0.0",+ "npm-run-path": "^5.1.0",+ "onetime": "^6.0.0",+ "signal-exit": "^4.1.0",+ "strip-final-newline": "^3.0.0"+ },+ "engines": {+ "node": ">=16.17"+ },+ "funding": {+ "url": "https://github.com/sindresorhus/execa?sponsor=1"+ }+ },+ "node_modules/execa/node_modules/signal-exit": {+ "version": "4.1.0",+ "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",+ "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",+ "dev": true,+ "license": "ISC",+ "engines": {+ "node": ">=14"+ },+ "funding": {+ "url": "https://github.com/sponsors/isaacs"+ }+ },+ "node_modules/fs-minipass": {+ "version": "2.1.0",+ "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",+ "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",+ "license": "ISC",+ "dependencies": {+ "minipass": "^3.0.0"+ },+ "engines": {+ "node": ">= 8"+ }+ },+ "node_modules/fs-minipass/node_modules/minipass": {+ "version": "3.3.6",+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",+ "license": "ISC",+ "dependencies": {+ "yallist": "^4.0.0"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/fs.realpath": {+ "version": "1.0.0",+ "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",+ "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",+ "license": "ISC"+ },+ "node_modules/fsevents": {+ "version": "2.3.3",+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",+ "dev": true,+ "hasInstallScript": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ],+ "engines": {+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"+ }+ },+ "node_modules/gauge": {+ "version": "3.0.2",+ "resolved": "https://registry.npmjs.org/gauge/-/gauge-3.0.2.tgz",+ "integrity": "sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==",+ "deprecated": "This package is no longer supported.",+ "license": "ISC",+ "dependencies": {+ "aproba": "^1.0.3 || ^2.0.0",+ "color-support": "^1.1.2",+ "console-control-strings": "^1.0.0",+ "has-unicode": "^2.0.1",+ "object-assign": "^4.1.1",+ "signal-exit": "^3.0.0",+ "string-width": "^4.2.3",+ "strip-ansi": "^6.0.1",+ "wide-align": "^1.1.2"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/get-func-name": {+ "version": "2.0.2",+ "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.2.tgz",+ "integrity": "sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": "*"+ }+ },+ "node_modules/get-stream": {+ "version": "8.0.1",+ "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-8.0.1.tgz",+ "integrity": "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=16"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/glob": {+ "version": "7.2.3",+ "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",+ "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",+ "deprecated": "Glob versions prior to v9 are no longer supported",+ "license": "ISC",+ "dependencies": {+ "fs.realpath": "^1.0.0",+ "inflight": "^1.0.4",+ "inherits": "2",+ "minimatch": "^3.1.1",+ "once": "^1.3.0",+ "path-is-absolute": "^1.0.0"+ },+ "engines": {+ "node": "*"+ },+ "funding": {+ "url": "https://github.com/sponsors/isaacs"+ }+ },+ "node_modules/has-flag": {+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",+ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/has-unicode": {+ "version": "2.0.1",+ "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz",+ "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==",+ "license": "ISC"+ },+ "node_modules/html-escaper": {+ "version": "2.0.2",+ "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",+ "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/https-proxy-agent": {+ "version": "5.0.1",+ "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",+ "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",+ "license": "MIT",+ "dependencies": {+ "agent-base": "6",+ "debug": "4"+ },+ "engines": {+ "node": ">= 6"+ }+ },+ "node_modules/human-signals": {+ "version": "5.0.0",+ "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz",+ "integrity": "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==",+ "dev": true,+ "license": "Apache-2.0",+ "engines": {+ "node": ">=16.17.0"+ }+ },+ "node_modules/inflight": {+ "version": "1.0.6",+ "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",+ "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",+ "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",+ "license": "ISC",+ "dependencies": {+ "once": "^1.3.0",+ "wrappy": "1"+ }+ },+ "node_modules/inherits": {+ "version": "2.0.4",+ "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",+ "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",+ "license": "ISC"+ },+ "node_modules/is-fullwidth-code-point": {+ "version": "3.0.0",+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/is-stream": {+ "version": "3.0.0",+ "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz",+ "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": "^12.20.0 || ^14.13.1 || >=16.0.0"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/isexe": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",+ "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",+ "dev": true,+ "license": "ISC"+ },+ "node_modules/istanbul-lib-coverage": {+ "version": "3.2.2",+ "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",+ "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",+ "dev": true,+ "license": "BSD-3-Clause",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/istanbul-lib-report": {+ "version": "3.0.1",+ "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",+ "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",+ "dev": true,+ "license": "BSD-3-Clause",+ "dependencies": {+ "istanbul-lib-coverage": "^3.0.0",+ "make-dir": "^4.0.0",+ "supports-color": "^7.1.0"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/istanbul-lib-report/node_modules/make-dir": {+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",+ "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "semver": "^7.5.3"+ },+ "engines": {+ "node": ">=10"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/istanbul-lib-source-maps": {+ "version": "5.0.6",+ "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-5.0.6.tgz",+ "integrity": "sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==",+ "dev": true,+ "license": "BSD-3-Clause",+ "dependencies": {+ "@jridgewell/trace-mapping": "^0.3.23",+ "debug": "^4.1.1",+ "istanbul-lib-coverage": "^3.0.0"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/istanbul-reports": {+ "version": "3.2.0",+ "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",+ "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",+ "dev": true,+ "license": "BSD-3-Clause",+ "dependencies": {+ "html-escaper": "^2.0.0",+ "istanbul-lib-report": "^3.0.0"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/js-tokens": {+ "version": "9.0.1",+ "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz",+ "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/local-pkg": {+ "version": "0.5.1",+ "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-0.5.1.tgz",+ "integrity": "sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "mlly": "^1.7.3",+ "pkg-types": "^1.2.1"+ },+ "engines": {+ "node": ">=14"+ },+ "funding": {+ "url": "https://github.com/sponsors/antfu"+ }+ },+ "node_modules/loupe": {+ "version": "2.3.7",+ "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.7.tgz",+ "integrity": "sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "get-func-name": "^2.0.1"+ }+ },+ "node_modules/magic-string": {+ "version": "0.30.21",+ "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",+ "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@jridgewell/sourcemap-codec": "^1.5.5"+ }+ },+ "node_modules/magicast": {+ "version": "0.3.5",+ "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.3.5.tgz",+ "integrity": "sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@babel/parser": "^7.25.4",+ "@babel/types": "^7.25.4",+ "source-map-js": "^1.2.0"+ }+ },+ "node_modules/make-dir": {+ "version": "3.1.0",+ "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",+ "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",+ "license": "MIT",+ "dependencies": {+ "semver": "^6.0.0"+ },+ "engines": {+ "node": ">=8"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/make-dir/node_modules/semver": {+ "version": "6.3.1",+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",+ "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",+ "license": "ISC",+ "bin": {+ "semver": "bin/semver.js"+ }+ },+ "node_modules/merge-stream": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",+ "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/mimic-fn": {+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz",+ "integrity": "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=12"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/minimatch": {+ "version": "3.1.2",+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",+ "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",+ "license": "ISC",+ "dependencies": {+ "brace-expansion": "^1.1.7"+ },+ "engines": {+ "node": "*"+ }+ },+ "node_modules/minipass": {+ "version": "5.0.0",+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",+ "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==",+ "license": "ISC",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/minizlib": {+ "version": "2.1.2",+ "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz",+ "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==",+ "license": "MIT",+ "dependencies": {+ "minipass": "^3.0.0",+ "yallist": "^4.0.0"+ },+ "engines": {+ "node": ">= 8"+ }+ },+ "node_modules/minizlib/node_modules/minipass": {+ "version": "3.3.6",+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",+ "license": "ISC",+ "dependencies": {+ "yallist": "^4.0.0"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/mkdirp": {+ "version": "1.0.4",+ "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",+ "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",+ "license": "MIT",+ "bin": {+ "mkdirp": "bin/cmd.js"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/mlly": {+ "version": "1.8.0",+ "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.8.0.tgz",+ "integrity": "sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "acorn": "^8.15.0",+ "pathe": "^2.0.3",+ "pkg-types": "^1.3.1",+ "ufo": "^1.6.1"+ }+ },+ "node_modules/mlly/node_modules/pathe": {+ "version": "2.0.3",+ "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",+ "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/ms": {+ "version": "2.1.3",+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",+ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",+ "license": "MIT"+ },+ "node_modules/nanoid": {+ "version": "3.3.11",+ "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",+ "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",+ "dev": true,+ "funding": [+ {+ "type": "github",+ "url": "https://github.com/sponsors/ai"+ }+ ],+ "license": "MIT",+ "bin": {+ "nanoid": "bin/nanoid.cjs"+ },+ "engines": {+ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"+ }+ },+ "node_modules/node-addon-api": {+ "version": "5.1.0",+ "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz",+ "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA==",+ "license": "MIT"+ },+ "node_modules/node-fetch": {+ "version": "2.7.0",+ "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",+ "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",+ "license": "MIT",+ "dependencies": {+ "whatwg-url": "^5.0.0"+ },+ "engines": {+ "node": "4.x || >=6.0.0"+ },+ "peerDependencies": {+ "encoding": "^0.1.0"+ },+ "peerDependenciesMeta": {+ "encoding": {+ "optional": true+ }+ }+ },+ "node_modules/nopt": {+ "version": "5.0.0",+ "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz",+ "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==",+ "license": "ISC",+ "dependencies": {+ "abbrev": "1"+ },+ "bin": {+ "nopt": "bin/nopt.js"+ },+ "engines": {+ "node": ">=6"+ }+ },+ "node_modules/npm-run-path": {+ "version": "5.3.0",+ "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz",+ "integrity": "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "path-key": "^4.0.0"+ },+ "engines": {+ "node": "^12.20.0 || ^14.13.1 || >=16.0.0"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/npm-run-path/node_modules/path-key": {+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",+ "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=12"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/npmlog": {+ "version": "5.0.1",+ "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-5.0.1.tgz",+ "integrity": "sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==",+ "deprecated": "This package is no longer supported.",+ "license": "ISC",+ "dependencies": {+ "are-we-there-yet": "^2.0.0",+ "console-control-strings": "^1.1.0",+ "gauge": "^3.0.0",+ "set-blocking": "^2.0.0"+ }+ },+ "node_modules/object-assign": {+ "version": "4.1.1",+ "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",+ "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",+ "license": "MIT",+ "engines": {+ "node": ">=0.10.0"+ }+ },+ "node_modules/once": {+ "version": "1.4.0",+ "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",+ "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",+ "license": "ISC",+ "dependencies": {+ "wrappy": "1"+ }+ },+ "node_modules/onetime": {+ "version": "6.0.0",+ "resolved": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz",+ "integrity": "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "mimic-fn": "^4.0.0"+ },+ "engines": {+ "node": ">=12"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/p-limit": {+ "version": "5.0.0",+ "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-5.0.0.tgz",+ "integrity": "sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "yocto-queue": "^1.0.0"+ },+ "engines": {+ "node": ">=18"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/path-is-absolute": {+ "version": "1.0.1",+ "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",+ "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",+ "license": "MIT",+ "engines": {+ "node": ">=0.10.0"+ }+ },+ "node_modules/path-key": {+ "version": "3.1.1",+ "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",+ "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/pathe": {+ "version": "1.1.2",+ "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",+ "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/pathval": {+ "version": "1.1.1",+ "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz",+ "integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": "*"+ }+ },+ "node_modules/picocolors": {+ "version": "1.1.1",+ "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",+ "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",+ "dev": true,+ "license": "ISC"+ },+ "node_modules/pkg-types": {+ "version": "1.3.1",+ "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz",+ "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "confbox": "^0.1.8",+ "mlly": "^1.7.4",+ "pathe": "^2.0.1"+ }+ },+ "node_modules/pkg-types/node_modules/pathe": {+ "version": "2.0.3",+ "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",+ "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/postcss": {+ "version": "8.5.6",+ "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",+ "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",+ "dev": true,+ "funding": [+ {+ "type": "opencollective",+ "url": "https://opencollective.com/postcss/"+ },+ {+ "type": "tidelift",+ "url": "https://tidelift.com/funding/github/npm/postcss"+ },+ {+ "type": "github",+ "url": "https://github.com/sponsors/ai"+ }+ ],+ "license": "MIT",+ "dependencies": {+ "nanoid": "^3.3.11",+ "picocolors": "^1.1.1",+ "source-map-js": "^1.2.1"+ },+ "engines": {+ "node": "^10 || ^12 || >=14"+ }+ },+ "node_modules/pretty-format": {+ "version": "29.7.0",+ "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz",+ "integrity": "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@jest/schemas": "^29.6.3",+ "ansi-styles": "^5.0.0",+ "react-is": "^18.0.0"+ },+ "engines": {+ "node": "^14.15.0 || ^16.10.0 || >=18.0.0"+ }+ },+ "node_modules/react-is": {+ "version": "18.3.1",+ "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",+ "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/readable-stream": {+ "version": "3.6.2",+ "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",+ "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",+ "license": "MIT",+ "dependencies": {+ "inherits": "^2.0.3",+ "string_decoder": "^1.1.1",+ "util-deprecate": "^1.0.1"+ },+ "engines": {+ "node": ">= 6"+ }+ },+ "node_modules/rimraf": {+ "version": "3.0.2",+ "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",+ "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",+ "deprecated": "Rimraf versions prior to v4 are no longer supported",+ "license": "ISC",+ "dependencies": {+ "glob": "^7.1.3"+ },+ "bin": {+ "rimraf": "bin.js"+ },+ "funding": {+ "url": "https://github.com/sponsors/isaacs"+ }+ },+ "node_modules/rollup": {+ "version": "4.54.0",+ "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.54.0.tgz",+ "integrity": "sha512-3nk8Y3a9Ea8szgKhinMlGMhGMw89mqule3KWczxhIzqudyHdCIOHw8WJlj/r329fACjKLEh13ZSk7oE22kyeIw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@types/estree": "1.0.8"+ },+ "bin": {+ "rollup": "dist/bin/rollup"+ },+ "engines": {+ "node": ">=18.0.0",+ "npm": ">=8.0.0"+ },+ "optionalDependencies": {+ "@rollup/rollup-android-arm-eabi": "4.54.0",+ "@rollup/rollup-android-arm64": "4.54.0",+ "@rollup/rollup-darwin-arm64": "4.54.0",+ "@rollup/rollup-darwin-x64": "4.54.0",+ "@rollup/rollup-freebsd-arm64": "4.54.0",+ "@rollup/rollup-freebsd-x64": "4.54.0",+ "@rollup/rollup-linux-arm-gnueabihf": "4.54.0",+ "@rollup/rollup-linux-arm-musleabihf": "4.54.0",+ "@rollup/rollup-linux-arm64-gnu": "4.54.0",+ "@rollup/rollup-linux-arm64-musl": "4.54.0",+ "@rollup/rollup-linux-loong64-gnu": "4.54.0",+ "@rollup/rollup-linux-ppc64-gnu": "4.54.0",+ "@rollup/rollup-linux-riscv64-gnu": "4.54.0",+ "@rollup/rollup-linux-riscv64-musl": "4.54.0",+ "@rollup/rollup-linux-s390x-gnu": "4.54.0",+ "@rollup/rollup-linux-x64-gnu": "4.54.0",+ "@rollup/rollup-linux-x64-musl": "4.54.0",+ "@rollup/rollup-openharmony-arm64": "4.54.0",+ "@rollup/rollup-win32-arm64-msvc": "4.54.0",+ "@rollup/rollup-win32-ia32-msvc": "4.54.0",+ "@rollup/rollup-win32-x64-gnu": "4.54.0",+ "@rollup/rollup-win32-x64-msvc": "4.54.0",+ "fsevents": "~2.3.2"+ }+ },+ "node_modules/safe-buffer": {+ "version": "5.2.1",+ "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",+ "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",+ "funding": [+ {+ "type": "github",+ "url": "https://github.com/sponsors/feross"+ },+ {+ "type": "patreon",+ "url": "https://www.patreon.com/feross"+ },+ {+ "type": "consulting",+ "url": "https://feross.org/support"+ }+ ],+ "license": "MIT"+ },+ "node_modules/semver": {+ "version": "7.7.3",+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",+ "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",+ "license": "ISC",+ "bin": {+ "semver": "bin/semver.js"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/set-blocking": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",+ "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",+ "license": "ISC"+ },+ "node_modules/shebang-command": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",+ "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "shebang-regex": "^3.0.0"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/shebang-regex": {+ "version": "3.0.0",+ "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",+ "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/siginfo": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",+ "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",+ "dev": true,+ "license": "ISC"+ },+ "node_modules/signal-exit": {+ "version": "3.0.7",+ "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",+ "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",+ "license": "ISC"+ },+ "node_modules/source-map-js": {+ "version": "1.2.1",+ "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",+ "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",+ "dev": true,+ "license": "BSD-3-Clause",+ "engines": {+ "node": ">=0.10.0"+ }+ },+ "node_modules/stackback": {+ "version": "0.0.2",+ "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",+ "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/std-env": {+ "version": "3.10.0",+ "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",+ "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/string_decoder": {+ "version": "1.3.0",+ "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",+ "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",+ "license": "MIT",+ "dependencies": {+ "safe-buffer": "~5.2.0"+ }+ },+ "node_modules/string-width": {+ "version": "4.2.3",+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",+ "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",+ "license": "MIT",+ "dependencies": {+ "emoji-regex": "^8.0.0",+ "is-fullwidth-code-point": "^3.0.0",+ "strip-ansi": "^6.0.1"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/strip-ansi": {+ "version": "6.0.1",+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",+ "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",+ "license": "MIT",+ "dependencies": {+ "ansi-regex": "^5.0.1"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/strip-final-newline": {+ "version": "3.0.0",+ "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz",+ "integrity": "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=12"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/strip-literal": {+ "version": "2.1.1",+ "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-2.1.1.tgz",+ "integrity": "sha512-631UJ6O00eNGfMiWG78ck80dfBab8X6IVFB51jZK5Icd7XAs60Z5y7QdSd/wGIklnWvRbUNloVzhOKKmutxQ6Q==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "js-tokens": "^9.0.1"+ },+ "funding": {+ "url": "https://github.com/sponsors/antfu"+ }+ },+ "node_modules/supports-color": {+ "version": "7.2.0",+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",+ "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "has-flag": "^4.0.0"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/tar": {+ "version": "6.2.1",+ "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",+ "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==",+ "license": "ISC",+ "dependencies": {+ "chownr": "^2.0.0",+ "fs-minipass": "^2.0.0",+ "minipass": "^5.0.0",+ "minizlib": "^2.1.1",+ "mkdirp": "^1.0.3",+ "yallist": "^4.0.0"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/test-exclude": {+ "version": "6.0.0",+ "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz",+ "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "@istanbuljs/schema": "^0.1.2",+ "glob": "^7.1.4",+ "minimatch": "^3.0.4"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/tinybench": {+ "version": "2.9.0",+ "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",+ "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/tinypool": {+ "version": "0.8.4",+ "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.8.4.tgz",+ "integrity": "sha512-i11VH5gS6IFeLY3gMBQ00/MmLncVP7JLXOw1vlgkytLmJK7QnEr7NXf0LBdxfmNPAeyetukOk0bOYrJrFGjYJQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=14.0.0"+ }+ },+ "node_modules/tinyspy": {+ "version": "2.2.1",+ "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-2.2.1.tgz",+ "integrity": "sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=14.0.0"+ }+ },+ "node_modules/tr46": {+ "version": "0.0.3",+ "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",+ "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",+ "license": "MIT"+ },+ "node_modules/type-detect": {+ "version": "4.1.0",+ "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.1.0.tgz",+ "integrity": "sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=4"+ }+ },+ "node_modules/typescript": {+ "version": "5.9.3",+ "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",+ "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",+ "dev": true,+ "license": "Apache-2.0",+ "bin": {+ "tsc": "bin/tsc",+ "tsserver": "bin/tsserver"+ },+ "engines": {+ "node": ">=14.17"+ }+ },+ "node_modules/ufo": {+ "version": "1.6.1",+ "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.6.1.tgz",+ "integrity": "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/undici-types": {+ "version": "6.21.0",+ "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",+ "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/util-deprecate": {+ "version": "1.0.2",+ "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",+ "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",+ "license": "MIT"+ },+ "node_modules/vite": {+ "version": "5.4.21",+ "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",+ "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "esbuild": "^0.21.3",+ "postcss": "^8.4.43",+ "rollup": "^4.20.0"+ },+ "bin": {+ "vite": "bin/vite.js"+ },+ "engines": {+ "node": "^18.0.0 || >=20.0.0"+ },+ "funding": {+ "url": "https://github.com/vitejs/vite?sponsor=1"+ },+ "optionalDependencies": {+ "fsevents": "~2.3.3"+ },+ "peerDependencies": {+ "@types/node": "^18.0.0 || >=20.0.0",+ "less": "*",+ "lightningcss": "^1.21.0",+ "sass": "*",+ "sass-embedded": "*",+ "stylus": "*",+ "sugarss": "*",+ "terser": "^5.4.0"+ },+ "peerDependenciesMeta": {+ "@types/node": {+ "optional": true+ },+ "less": {+ "optional": true+ },+ "lightningcss": {+ "optional": true+ },+ "sass": {+ "optional": true+ },+ "sass-embedded": {+ "optional": true+ },+ "stylus": {+ "optional": true+ },+ "sugarss": {+ "optional": true+ },+ "terser": {+ "optional": true+ }+ }+ },+ "node_modules/vite-node": {+ "version": "1.6.1",+ "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-1.6.1.tgz",+ "integrity": "sha512-YAXkfvGtuTzwWbDSACdJSg4A4DZiAqckWe90Zapc/sEX3XvHcw1NdurM/6od8J207tSDqNbSsgdCacBgvJKFuA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "cac": "^6.7.14",+ "debug": "^4.3.4",+ "pathe": "^1.1.1",+ "picocolors": "^1.0.0",+ "vite": "^5.0.0"+ },+ "bin": {+ "vite-node": "vite-node.mjs"+ },+ "engines": {+ "node": "^18.0.0 || >=20.0.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ }+ },+ "node_modules/vitest": {+ "version": "1.6.1",+ "resolved": "https://registry.npmjs.org/vitest/-/vitest-1.6.1.tgz",+ "integrity": "sha512-Ljb1cnSJSivGN0LqXd/zmDbWEM0RNNg2t1QW/XUhYl/qPqyu7CsqeWtqQXHVaJsecLPuDoak2oJcZN2QoRIOag==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@vitest/expect": "1.6.1",+ "@vitest/runner": "1.6.1",+ "@vitest/snapshot": "1.6.1",+ "@vitest/spy": "1.6.1",+ "@vitest/utils": "1.6.1",+ "acorn-walk": "^8.3.2",+ "chai": "^4.3.10",+ "debug": "^4.3.4",+ "execa": "^8.0.1",+ "local-pkg": "^0.5.0",+ "magic-string": "^0.30.5",+ "pathe": "^1.1.1",+ "picocolors": "^1.0.0",+ "std-env": "^3.5.0",+ "strip-literal": "^2.0.0",+ "tinybench": "^2.5.1",+ "tinypool": "^0.8.3",+ "vite": "^5.0.0",+ "vite-node": "1.6.1",+ "why-is-node-running": "^2.2.2"+ },+ "bin": {+ "vitest": "vitest.mjs"+ },+ "engines": {+ "node": "^18.0.0 || >=20.0.0"+ },+ "funding": {+ "url": "https://opencollective.com/vitest"+ },+ "peerDependencies": {+ "@edge-runtime/vm": "*",+ "@types/node": "^18.0.0 || >=20.0.0",+ "@vitest/browser": "1.6.1",+ "@vitest/ui": "1.6.1",+ "happy-dom": "*",+ "jsdom": "*"+ },+ "peerDependenciesMeta": {+ "@edge-runtime/vm": {+ "optional": true+ },+ "@types/node": {+ "optional": true+ },+ "@vitest/browser": {+ "optional": true+ },+ "@vitest/ui": {+ "optional": true+ },+ "happy-dom": {+ "optional": true+ },+ "jsdom": {+ "optional": true+ }+ }+ },+ "node_modules/webidl-conversions": {+ "version": "3.0.1",+ "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",+ "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",+ "license": "BSD-2-Clause"+ },+ "node_modules/whatwg-url": {+ "version": "5.0.0",+ "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",+ "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",+ "license": "MIT",+ "dependencies": {+ "tr46": "~0.0.3",+ "webidl-conversions": "^3.0.0"+ }+ },+ "node_modules/which": {+ "version": "2.0.2",+ "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",+ "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "isexe": "^2.0.0"+ },+ "bin": {+ "node-which": "bin/node-which"+ },+ "engines": {+ "node": ">= 8"+ }+ },+ "node_modules/why-is-node-running": {+ "version": "2.3.0",+ "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",+ "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "siginfo": "^2.0.0",+ "stackback": "0.0.2"+ },+ "bin": {+ "why-is-node-running": "cli.js"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/wide-align": {+ "version": "1.1.5",+ "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz",+ "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==",+ "license": "ISC",+ "dependencies": {+ "string-width": "^1.0.2 || 2 || 3 || 4"+ }+ },+ "node_modules/wrappy": {+ "version": "1.0.2",+ "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",+ "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",+ "license": "ISC"+ },+ "node_modules/yallist": {+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",+ "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",+ "license": "ISC"+ },+ "node_modules/yocto-queue": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.2.2.tgz",+ "integrity": "sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=12.20"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/zod": {+ "version": "3.25.76",+ "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",+ "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",+ "license": "MIT",+ "funding": {+ "url": "https://github.com/sponsors/colinhacks"+ }+ }+ }+}