Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 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

checkpoint: File edit:

rUv5f5c4f7d4b98
diff --git a/v3/__tests__/unit/security/token-generator.test.ts b/v3/__tests__/unit/security/token-generator.test.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.json
new file mode 100644
index 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"
+ }
+ }
+ }
+}