diff --git a/.fernignore b/.fernignore index e9e36859..93883fa6 100644 --- a/.fernignore +++ b/.fernignore @@ -6,14 +6,17 @@ LICENSE README.md build.js scripts/ -src/cache.test.ts -src/cache.ts +src/cache/ src/core/fetcher/custom.ts +src/datastream/ src/events.test.ts src/events.ts src/index.ts src/logger.ts +src/rules-engine.test.ts +src/rules-engine.ts src/version.ts +src/wasm/ src/webhooks.ts src/wrapper.ts tests/unit/webhooks.test.ts diff --git a/build.js b/build.js index 072000dd..784ab0a7 100644 --- a/build.js +++ b/build.js @@ -1,6 +1,7 @@ // build.js const esbuild = require('esbuild'); const { execSync } = require('child_process'); +const { copyFileSync } = require('fs'); const sharedConfig = { entryPoints: ['src/index.ts'], @@ -32,6 +33,11 @@ async function build() { console.log('✅ JavaScript build completed with esbuild'); + // Copy WASM files to dist + console.log('🔧 Copying WASM files...'); + copyFileSync('src/wasm/rulesengine_bg.wasm', 'dist/rulesengine_bg.wasm'); + console.log('✅ WASM files copied'); + // Generate TypeScript declarations with tsc console.log('🔧 Generating TypeScript declarations...'); execSync('tsc --emitDeclarationOnly --outDir dist', { stdio: 'inherit' }); diff --git a/package.json b/package.json index afea1608..a1019427 100644 --- a/package.json +++ b/package.json @@ -50,7 +50,9 @@ "path": false, "stream": false, "crypto": false, - "timers": false + "timers": false, + "url": false, + "ws": false }, "packageManager": "yarn@1.22.22", "engines": { @@ -61,6 +63,7 @@ "files": [ "dist/**/*.js", "dist/**/*.d.ts", + "dist/**/*.wasm", "!dist/**/*.js.map", "!dist/**/*.test.*", "README.md" diff --git a/src/cache/index.ts b/src/cache/index.ts new file mode 100644 index 00000000..ac6ae9bd --- /dev/null +++ b/src/cache/index.ts @@ -0,0 +1,8 @@ +// Cache interfaces and types +export { type CacheProvider, type CacheOptions } from "./types"; + +// Memory cache implementation +export { LocalCache } from "./local"; + +// Redis cache implementation (requires 'redis' package) +export { RedisCacheProvider, type RedisOptions } from "./redis"; \ No newline at end of file diff --git a/src/cache.test.ts b/src/cache/local.test.ts similarity index 91% rename from src/cache.test.ts rename to src/cache/local.test.ts index fe31f5e3..3373f0c7 100644 --- a/src/cache.test.ts +++ b/src/cache/local.test.ts @@ -1,6 +1,6 @@ /* eslint @typescript-eslint/no-explicit-any: 0 */ -import { LocalCache } from "./cache"; +import { LocalCache } from "./local"; jest.useFakeTimers(); @@ -12,7 +12,6 @@ describe("LocalCache", () => { }); afterEach(() => { - cache.resetCache(); jest.clearAllTimers(); }); @@ -26,7 +25,7 @@ describe("LocalCache", () => { await cache.set("key1", { data: "value1" }, 1000); // TTL: 1 second jest.advanceTimersByTime(1001); // Advance time by 1 second and 1 millisecond const value = await cache.get("key1"); - expect(value).toBeUndefined(); + expect(value).toBeNull(); }); it("should evict least recently used item when maxItems is exceeded", async () => { @@ -50,10 +49,9 @@ describe("LocalCache", () => { const value4 = await smallCache.get("key4"); expect(value1).toEqual({ data: "value1" }); - expect(value2).toBeUndefined(); // key2 should be evicted + expect(value2).toBeNull(); // key2 should be evicted expect(value3).toEqual({ data: "value3" }); expect(value4).toEqual({ data: "value4" }); - smallCache.resetCache(); }); it("should update the access counter on get", async () => { @@ -83,8 +81,7 @@ describe("LocalCache", () => { const zeroItemCache = new LocalCache({ maxItems: 0 }); await zeroItemCache.set("key1", { data: "value1" }); const value = await zeroItemCache.get("key1"); - expect(value).toBeUndefined(); - zeroItemCache.resetCache(); + expect(value).toBeNull(); }); it("should maintain the correct number of items", async () => { @@ -96,6 +93,5 @@ describe("LocalCache", () => { } expect((testCache as any).cache.size).toBe(maxItems); - testCache.resetCache(); }); }); diff --git a/src/cache.ts b/src/cache/local.ts similarity index 76% rename from src/cache.ts rename to src/cache/local.ts index ea219ef9..a31d3e54 100644 --- a/src/cache.ts +++ b/src/cache/local.ts @@ -1,9 +1,5 @@ import { setTimeout, clearTimeout } from "timers"; - -interface CacheProvider { - get(key: string): Promise; - set(key: string, value: T, ttlOverride?: number): Promise; -} +import { CacheProvider, CacheOptions } from "./types"; type CacheItem = { value: T; @@ -12,11 +8,9 @@ type CacheItem = { timeoutId?: ReturnType; }; -export interface CacheOptions { - maxItems?: number; - ttl?: number; -} - +/** + * In-memory cache implementation with LRU eviction and TTL support + */ class LocalCache implements CacheProvider { private cache: Map>; private maxItems: number; @@ -29,14 +23,14 @@ class LocalCache implements CacheProvider { this.defaultTTL = ttl; } - async get(key: string): Promise { + async get(key: string): Promise { const item = this.cache.get(key); - if (!item) return undefined; + if (!item) return null; // Check if the item has expired if (item.expiration <= Date.now()) { this.evictItem(key, item); - return undefined; + return null; } // Update the access counter for LRU eviction @@ -71,19 +65,27 @@ class LocalCache implements CacheProvider { value, accessCounter: this.accessCounter, expiration: Date.now() + ttl, - timeoutId: setTimeout(() => this.evictItem(key, newItem), ttl), }; + + // Set timeout after item is created to avoid circular reference + newItem.timeoutId = setTimeout(() => this.evictItem(key, newItem), ttl); this.cache.set(key, newItem); } - resetCache(): void { - this.cache.forEach((item) => { - if (item.timeoutId) { - clearTimeout(item.timeoutId); + async delete(key: string): Promise { + const item = this.cache.get(key); + if (item) { + this.evictItem(key, item); + } + } + + async deleteMissing(keysToKeep: string[], _?: { scanPattern?: string }): Promise { + const keysToKeepSet = new Set(keysToKeep); + for (const [key, item] of this.cache) { + if (!keysToKeepSet.has(key)) { + this.evictItem(key, item); } - }); - this.cache.clear(); - this.accessCounter = 0; + } } private evictItem(key: string, item: CacheItem): void { diff --git a/src/cache/redis.ts b/src/cache/redis.ts new file mode 100644 index 00000000..26709549 --- /dev/null +++ b/src/cache/redis.ts @@ -0,0 +1,188 @@ +import { CacheProvider, CacheOptions } from "./types"; + +export interface RedisOptions extends CacheOptions { + /** Redis connection URL (e.g., 'redis://localhost:6379') */ + url?: string; + /** Redis host (default: 'localhost') */ + host?: string; + /** Redis port (default: 6379) */ + port?: number; + /** Redis password */ + password?: string; + /** Redis database number (default: 0) */ + db?: number; + /** Redis key prefix for all cache keys (default: 'schematic:') */ + keyPrefix?: string; +} + +/** + * Redis-based cache provider implementation + * Requires the 'redis' package to be installed: npm install redis + */ +export class RedisCacheProvider implements CacheProvider { + private client: any; // Redis client type + private defaultTTL: number; + private keyPrefix: string; + private isConnected: boolean = false; + private initPromise: Promise; + + constructor(options: RedisOptions = {}) { + this.defaultTTL = Math.floor((options.ttl || 5000) / 1000); // Convert to seconds for Redis + this.keyPrefix = options.keyPrefix || 'schematic:'; + + // Dynamically import Redis to avoid requiring it if not used + this.initPromise = this.initRedisClient(options); + } + + private async initRedisClient(options: RedisOptions): Promise { + try { + // Dynamically import redis so it's only loaded if actually used + const redisModule = await import('redis' as any); + const { createClient } = redisModule; + + let clientConfig: any = {}; + + if (options.url) { + clientConfig.url = options.url; + } else { + clientConfig.socket = { + host: options.host || 'localhost', + port: options.port || 6379, + }; + + if (options.password) { + clientConfig.password = options.password; + } + + if (options.db !== undefined) { + clientConfig.database = options.db; + } + } + + this.client = createClient(clientConfig); + + this.client.on('error', () => { + this.isConnected = false; + }); + + this.client.on('connect', () => { + this.isConnected = true; + }); + + this.client.on('disconnect', () => { + this.isConnected = false; + }); + + await this.client.connect(); + + } catch (error) { + throw new Error( + 'Redis package not found. Please install it with: npm install redis\n' + + 'Original error: ' + (error as Error).message + ); + } + } + + private getFullKey(key: string): string { + return this.keyPrefix + key; + } + + async get(key: string): Promise { + await this.initPromise; + + if (!this.isConnected || !this.client) { + return null; + } + + const fullKey = this.getFullKey(key); + const value = await this.client.get(fullKey); + + if (value === null) { + return null; + } + + return JSON.parse(value) as T; + } + + async set(key: string, value: T, ttl?: number): Promise { + await this.initPromise; + + if (!this.isConnected || !this.client) { + return; + } + + const fullKey = this.getFullKey(key); + const serializedValue = JSON.stringify(value); + const actualTTL = ttl ? Math.floor(ttl / 1000) : this.defaultTTL; + + if (actualTTL > 0) { + await this.client.setEx(fullKey, actualTTL, serializedValue); + } else { + await this.client.set(fullKey, serializedValue); + } + } + + async delete(key: string): Promise { + await this.initPromise; + + if (!this.isConnected || !this.client) { + return; + } + + const fullKey = this.getFullKey(key); + await this.client.del(fullKey); + } + + async deleteMissing(keysToKeep: string[], options?: { scanPattern?: string }): Promise { + await this.initPromise; + + if (!this.isConnected || !this.client) { + return; + } + + // Get all keys with our prefix using SCAN (non-blocking) + // Allow more specific pattern to reduce keys scanned (e.g., 'flag:*' to only scan flag keys) + const pattern = options?.scanPattern + ? this.keyPrefix + options.scanPattern + : this.keyPrefix + '*'; + const fullKeysToKeep = new Set(keysToKeep.map(k => this.getFullKey(k))); + const keysToDelete: string[] = []; + const batchSize = 1000; + + for await (const key of this.client.scanIterator({ MATCH: pattern, COUNT: 1000 })) { + if (!fullKeysToKeep.has(key)) { + keysToDelete.push(key); + + // Delete in batches to avoid memory buildup with millions of keys + if (keysToDelete.length >= batchSize) { + await this.client.del(keysToDelete); + keysToDelete.length = 0; // Clear array + } + } + } + + // Delete remaining keys + if (keysToDelete.length > 0) { + await this.client.del(keysToDelete); + } + } + + /** + * Close the Redis connection + */ + async close(): Promise { + await this.initPromise; + + if (this.client) { + await this.client.quit(); + this.isConnected = false; + } + } + + /** + * Check if the Redis client is connected + */ + isReady(): boolean { + return this.isConnected; + } +} \ No newline at end of file diff --git a/src/cache/types.ts b/src/cache/types.ts new file mode 100644 index 00000000..2410d484 --- /dev/null +++ b/src/cache/types.ts @@ -0,0 +1,18 @@ +/** + * Cache provider interface for storing and retrieving entities + */ +export interface CacheProvider { + /** Get a value from cache */ + get(key: string): Promise; + /** Set a value in cache */ + set(key: string, value: T, ttl?: number): Promise; + /** Delete a value from cache */ + delete(key: string): Promise; + /** Delete all keys not in the keysToKeep array (optional, for bulk operations) */ + deleteMissing?(keysToKeep: string[], options?: { scanPattern?: string }): Promise; +} + +export interface CacheOptions { + maxItems?: number; + ttl?: number; +} \ No newline at end of file diff --git a/src/datastream/datastream-client.test.ts b/src/datastream/datastream-client.test.ts new file mode 100644 index 00000000..214aa7b4 --- /dev/null +++ b/src/datastream/datastream-client.test.ts @@ -0,0 +1,597 @@ +import { EventEmitter } from 'events'; +import { + DataStreamClient, + DataStreamClientOptions, +} from './datastream-client'; +import { LocalCache } from '../cache/local'; +import { DatastreamWSClient } from './websocket-client'; +import { DataStreamResp, EntityType, MessageType } from './types'; +import { Logger } from '../logger'; +import * as Schematic from '../api/types'; + +// Mock DatastreamWSClient +const mockDatastreamWSClientInstanceInstance = { + on: jest.fn(), + start: jest.fn(), + close: jest.fn(), + isConnected: jest.fn().mockReturnValue(true), + isReady: jest.fn().mockReturnValue(true), + sendMessage: jest.fn().mockResolvedValue(undefined), +}; + +jest.mock('./client', () => { + return { + DatastreamWSClient: jest.fn().mockImplementation(() => mockDatastreamWSClientInstanceInstance), + }; +}); + +describe('DataStreamClient', () => { + let client: DataStreamClient; + let mockLogger: Logger; + let options: DataStreamClientOptions; + + const mockCompany: Schematic.RulesengineCompany = { + id: 'company-123', + accountId: 'account-123', + environmentId: 'env-123', + keys: { name: 'Test Company' }, + traits: [], + rules: [], + metrics: [], + planIds: [], + billingProductIds: [], + crmProductIds: [], + creditBalances: {}, + }; + + const mockUser: Schematic.RulesengineUser = { + id: 'user-123', + accountId: 'account-123', + environmentId: 'env-123', + keys: { email: 'test@example.com' }, + traits: [], + rules: [], + }; + + const mockFlag: Schematic.RulesengineFlag = { + id: 'flag-123', + key: 'test-flag', + accountId: 'account-123', + environmentId: 'env-123', + defaultValue: false, + rules: [], + }; + + beforeEach(() => { + jest.clearAllMocks(); + // Reset sendMessage to default implementation + mockDatastreamWSClientInstanceInstance.sendMessage.mockResolvedValue(undefined); + + mockLogger = { + debug: jest.fn(), + info: jest.fn(), + warn: jest.fn(), + error: jest.fn(), + }; + + options = { + apiKey: 'test-api-key', + baseURL: 'https://api.schematichq.com', + logger: mockLogger, + }; + + client = new DataStreamClient(options); + }); + + afterEach(async () => { + if (client) { + // Remove all listeners to prevent memory leaks + client.removeAllListeners(); + client.close(); + // Wait for any pending process.nextTick operations to complete + await new Promise(resolve => setImmediate(resolve)); + } + jest.clearAllMocks(); + // Reset sendMessage to default implementation + mockDatastreamWSClientInstanceInstance.sendMessage.mockResolvedValue(undefined); + }); + + test('should initialize with default options', () => { + expect(client).toBeInstanceOf(DataStreamClient); + expect(client.isConnected()).toBe(false); + }); + + test('should initialize with custom cache providers', () => { + const customCompanyCache = new LocalCache(); + const customUserCache = new LocalCache(); + const customFlagCache = new LocalCache(); + + const clientWithCustomCaches = new DataStreamClient({ + ...options, + companyCache: customCompanyCache, + userCache: customUserCache, + flagCache: customFlagCache, + }); + + expect(clientWithCustomCaches).toBeInstanceOf(DataStreamClient); + }); + + test('should use different TTL for flag cache than other caches', () => { + // Test with a custom cacheTTL that's shorter than MAX_CACHE_TTL (30 days) + const customCacheTTL = 12 * 60 * 60 * 1000; // 12 hours + const clientWithCustomTTL = new DataStreamClient({ + ...options, + cacheTTL: customCacheTTL, + }); + + expect(clientWithCustomTTL).toBeInstanceOf(DataStreamClient); + + // Test with a custom cacheTTL that's longer than MAX_CACHE_TTL (30 days) + // In this case, flag cache should use the custom TTL, not MAX_CACHE_TTL + const longCacheTTL = 45 * 24 * 60 * 60 * 1000; // 45 days + const clientWithLongTTL = new DataStreamClient({ + ...options, + cacheTTL: longCacheTTL, + }); + + expect(clientWithLongTTL).toBeInstanceOf(DataStreamClient); + // The internal behavior follows Go logic: max(MAX_CACHE_TTL, configured TTL) for flags + // This ensures flag cache always has at least 30 days TTL, or more if configured + }); + + test('should start WebSocket client when started', async () => { + await client.start(); + + expect(DatastreamWSClient).toHaveBeenCalledWith({ + url: options.baseURL, + apiKey: options.apiKey, + messageHandler: expect.any(Function), + connectionReadyHandler: expect.any(Function), + logger: mockLogger, + }); + expect(mockDatastreamWSClientInstanceInstance.start).toHaveBeenCalled(); + }); + + test('should handle WebSocket events', async () => { + const connectSpy = jest.fn(); + const disconnectSpy = jest.fn(); + const readySpy = jest.fn(); + const errorSpy = jest.fn(); + + client.on('connected', connectSpy); + client.on('disconnected', disconnectSpy); + client.on('ready', readySpy); + client.on('error', errorSpy); + + await client.start(); + + // Simulate WebSocket events + const onCalls = mockDatastreamWSClientInstanceInstance.on.mock.calls; + const connectedHandler = onCalls.find((call: any) => call[0] === 'connected')?.[1]; + const disconnectedHandler = onCalls.find((call: any) => call[0] === 'disconnected')?.[1]; + const readyHandler = onCalls.find((call: any) => call[0] === 'ready')?.[1]; + const errorHandler = onCalls.find((call: any) => call[0] === 'error')?.[1]; + + if (connectedHandler) connectedHandler(); + if (disconnectedHandler) disconnectedHandler(); + if (readyHandler) readyHandler(); + if (errorHandler) errorHandler(new Error('test error')); + + expect(connectSpy).toHaveBeenCalled(); + expect(disconnectSpy).toHaveBeenCalled(); + expect(readySpy).toHaveBeenCalled(); + expect(errorSpy).toHaveBeenCalledWith(new Error('test error')); + }); + + test('should handle company messages and update cache', async () => { + await client.start(); + + // Get message handler + const DatastreamWSClientMock = DatastreamWSClient as jest.MockedClass; + const messageHandler = DatastreamWSClientMock.mock.calls[0][0].messageHandler; + + // Create company message + const companyMessage: DataStreamResp = { + entity_type: EntityType.COMPANY, + message_type: MessageType.FULL, + data: mockCompany, + }; + + // Handle message + await messageHandler({}, companyMessage); + + // Verify company is cached and can be retrieved using the correct keys + const retrievedCompany = await client.getCompany(mockCompany.keys!); + expect(retrievedCompany).toEqual(mockCompany); + }, 10000); + + test('should handle user messages and update cache', async () => { + await client.start(); + + // Get message handler + const DatastreamWSClientMock = DatastreamWSClient as jest.MockedClass; + const messageHandler = DatastreamWSClientMock.mock.calls[0][0].messageHandler; + + // Create user message + const userMessage: DataStreamResp = { + entity_type: EntityType.USER, + message_type: MessageType.FULL, + data: mockUser, + }; + + // Handle message + await messageHandler({}, userMessage); + + // Verify user is cached and can be retrieved using the correct keys + const retrievedUser = await client.getUser(mockUser.keys!); + expect(retrievedUser).toEqual(mockUser); + }, 10000); + + test('should handle flag messages and update cache', async () => { + await client.start(); + + // Get message handler + const DatastreamWSClientMock = DatastreamWSClient as jest.MockedClass; + const messageHandler = DatastreamWSClientMock.mock.calls[0][0].messageHandler; + + // Create flag message + const flagMessage: DataStreamResp = { + entity_type: EntityType.FLAGS, + message_type: MessageType.FULL, + data: [mockFlag], // Flags can be sent as array + }; + + // Handle message + await messageHandler({}, flagMessage); + + // Verify flag is cached and can be retrieved + const retrievedFlag = await client.getFlag(mockFlag.key); + expect(retrievedFlag).toEqual(mockFlag); + }); + + test('should request data from datastream when not in cache', async () => { + // Set up connected state + mockDatastreamWSClientInstanceInstance.isConnected.mockReturnValue(true); + + await client.start(); + + // Get message handler + const DatastreamWSClientMock = DatastreamWSClient as jest.MockedClass; + const messageHandler = DatastreamWSClientMock.mock.calls[0][0].messageHandler; + + // Get the connection handler from the WebSocket client mock + const onCalls = mockDatastreamWSClientInstanceInstance.on.mock.calls; + const connectedHandler = onCalls.find((call: any) => call[0] === 'connected')?.[1]; + + // Mock sendMessage to automatically trigger response + mockDatastreamWSClientInstanceInstance.sendMessage.mockImplementation(async (message: any) => { + if (message.data?.entity_type === EntityType.COMPANY) { + const responseCompany = { + ...mockCompany, + id: 'company-456', + keys: { id: 'company-456' } + }; + const companyMessage: DataStreamResp = { + entity_type: EntityType.COMPANY, + message_type: MessageType.FULL, + data: responseCompany, + }; + // Use process.nextTick for immediate execution + process.nextTick(() => { + messageHandler({}, companyMessage); + }); + } + }); + + // Simulate connected state + if (connectedHandler) connectedHandler(); + + // Request company not in cache - should send datastream request and get response + const result = await client.getCompany({ id: 'company-456' }); + + // Verify request was sent + expect(mockDatastreamWSClientInstanceInstance.sendMessage).toHaveBeenCalledWith({ + data: { + entity_type: EntityType.COMPANY, + keys: { id: 'company-456' }, + } + }); + + // Verify we got the expected result + expect(result.id).toBe('company-456'); + }); + + test('should handle multiple pending requests for same entity', async () => { + mockDatastreamWSClientInstanceInstance.isConnected.mockReturnValue(true); + + let sentRequestCount = 0; + + await client.start(); + + // Get message handler + const DatastreamWSClientMock = DatastreamWSClient as jest.MockedClass; + const messageHandler = DatastreamWSClientMock.mock.calls[0][0].messageHandler; + + // Get the connection handler from the WebSocket client mock + const onCalls = mockDatastreamWSClientInstanceInstance.on.mock.calls; + const connectedHandler = onCalls.find((call: any) => call[0] === 'connected')?.[1]; + + // Mock sendMessage to track requests and auto-respond + mockDatastreamWSClientInstanceInstance.sendMessage.mockImplementation(async (message: any) => { + sentRequestCount++; + if (message.data?.entity_type === EntityType.COMPANY) { + const responseCompany = { + ...mockCompany, + id: 'company-789', + keys: { id: 'company-789' } + }; + const companyMessage: DataStreamResp = { + entity_type: EntityType.COMPANY, + message_type: MessageType.FULL, + data: responseCompany, + }; + // Use process.nextTick for immediate execution + process.nextTick(() => { + messageHandler({}, companyMessage); + }); + } + }); + + if (connectedHandler) connectedHandler(); + + // Make multiple requests for same company + const [result1, result2, result3] = await Promise.all([ + client.getCompany({ id: 'company-789' }), + client.getCompany({ id: 'company-789' }), + client.getCompany({ id: 'company-789' }) + ]); + + // Should only send one request for company (flags might be cached or not requested in this scenario) + expect(sentRequestCount).toBeGreaterThanOrEqual(1); // At least 1 for company + + // All promises should resolve with same company + expect(result1.id).toBe('company-789'); + expect(result2.id).toBe('company-789'); + expect(result3.id).toBe('company-789'); + expect(result1).toEqual(result2); + expect(result2).toEqual(result3); + }); + + test('should throw error when requesting data while disconnected', async () => { + // Don't start client or set connected state + mockDatastreamWSClientInstanceInstance.isConnected.mockReturnValue(false); + + await expect(client.getCompany({ id: 'company-123' })).rejects.toThrow('DataStream client is not connected'); + await expect(client.getUser({ id: 'user-123' })).rejects.toThrow('DataStream client is not connected'); + // Note: getFlag doesn't require connection, it only checks cache + }); + + test('should handle entity messages and update cache', async () => { + await client.start(); + + const DatastreamWSClientMock = DatastreamWSClient as jest.MockedClass; + const messageHandler = DatastreamWSClientMock.mock.calls[0][0].messageHandler; + + // Send company message + await messageHandler({}, { + entity_type: EntityType.COMPANY, + message_type: MessageType.FULL, + data: mockCompany, + }); + + // Send user message + await messageHandler({}, { + entity_type: EntityType.USER, + message_type: MessageType.FULL, + data: mockUser, + }); + + // Send flag message + await messageHandler({}, { + entity_type: EntityType.FLAGS, + message_type: MessageType.FULL, + data: [mockFlag], + }); + + // Verify entities are cached (no events expected) + const cachedCompany = await client.getCompany(mockCompany.keys!); + const cachedUser = await client.getUser(mockUser.keys!); + const cachedFlag = await client.getFlag(mockFlag.key); + + expect(cachedCompany).toEqual(mockCompany); + expect(cachedUser).toEqual(mockUser); + expect(cachedFlag).toEqual(mockFlag); + }); + + test('should handle error type messages from WebSocket', async () => { + const errorSpy = jest.fn(); + client.on('error', errorSpy); + + await client.start(); + + // Get message handler + const DatastreamWSClientMock = DatastreamWSClient as jest.MockedClass; + const messageHandler = DatastreamWSClientMock.mock.calls[0][0].messageHandler; + + // Test 1: Error message with entity type and keys (should notify pending requests and log warning) + const companyErrorMessage: DataStreamResp = { + entity_type: EntityType.COMPANY, + message_type: MessageType.ERROR, + data: { + error: 'Company not found', + entity_type: EntityType.COMPANY, + keys: { id: 'company-not-found' } + } + }; + + await messageHandler({}, companyErrorMessage); + + // Verify warning was logged but no error event was emitted + expect(mockLogger.warn).toHaveBeenCalledWith({}, 'DataStream error received: Company not found'); + + // Test 2: Error message with entity type and keys for user + const userErrorMessage: DataStreamResp = { + entity_type: EntityType.USER, + message_type: MessageType.ERROR, + data: { + error: 'User not found', + entity_type: EntityType.USER, + keys: { id: 'user-not-found' } + } + }; + + await messageHandler({}, userErrorMessage); + + // Verify warning was logged + expect(mockLogger.warn).toHaveBeenCalledWith({}, 'DataStream error received: User not found'); + + // Test 3: Generic error message without entity type or keys + const genericErrorMessage: DataStreamResp = { + entity_type: 'unknown', + message_type: MessageType.ERROR, + data: { + error: 'Generic datastream error' + } + }; + + await messageHandler({}, genericErrorMessage); + + // Verify warning was logged + expect(mockLogger.warn).toHaveBeenCalledWith({}, 'DataStream error received: Generic datastream error'); + + // Test 4: Error message with no error text (should use default) + const noErrorTextMessage: DataStreamResp = { + entity_type: 'unknown', + message_type: MessageType.ERROR, + data: {} + }; + + await messageHandler({}, noErrorTextMessage); + + // Verify warning was logged with default message + expect(mockLogger.warn).toHaveBeenCalledWith({}, 'DataStream error received: Unknown datastream error'); + + // Test 5: Unsupported entity type in error message should log warning + const unsupportedEntityErrorMessage: DataStreamResp = { + entity_type: EntityType.FLAGS, // FLAGS entity type is not supported for error handling + message_type: MessageType.ERROR, + data: { + error: 'Unsupported entity error', + entity_type: EntityType.FLAGS, + keys: { key: 'some-flag-key' } + } + }; + + await messageHandler({}, unsupportedEntityErrorMessage); + + // Verify warnings were logged for both unsupported entity type and the error message + expect(mockLogger.warn).toHaveBeenCalledWith({}, 'Received error for unsupported entity type: rulesengine.Flags'); + expect(mockLogger.warn).toHaveBeenCalledWith({}, 'DataStream error received: Unsupported entity error'); + + // Verify no error events were emitted throughout the test + expect(errorSpy).not.toHaveBeenCalled(); + }); + + test('should handle replicator mode configuration', () => { + const replicatorClient = new DataStreamClient({ + ...options, + replicatorMode: true, + replicatorHealthURL: 'http://localhost:8080/health', + replicatorHealthCheck: 10000, + }); + + expect(replicatorClient).toBeInstanceOf(DataStreamClient); + expect(replicatorClient.isReplicatorMode()).toBe(true); + expect(replicatorClient.getReplicatorCacheVersion()).toBeUndefined(); + }); + + test('should fetch and use replicator cache version', async () => { + // Mock global fetch + const originalFetch = global.fetch; + const mockFetch = jest.fn(); + global.fetch = mockFetch as any; + + mockFetch.mockResolvedValueOnce({ + ok: true, + json: async () => ({ + ready: true, + cache_version: 'v123' + }) + }); + + const replicatorClient = new DataStreamClient({ + ...options, + replicatorMode: true, + replicatorHealthURL: 'http://localhost:8080/health', + replicatorHealthCheck: 30000, // Long interval to prevent multiple calls + }); + + // Start the client to trigger initial health check + await replicatorClient.start(); + + // Wait a bit for the health check to complete + await new Promise(resolve => setTimeout(resolve, 50)); + + // Cache version should be set + expect(replicatorClient.getReplicatorCacheVersion()).toBe('v123'); + + replicatorClient.close(); + + // Restore original fetch + global.fetch = originalFetch; + }); + + test('should use rules engine version key for cache keys in non-replicator mode', async () => { + // Start the client (non-replicator mode) + await client.start(); + + // Try to get a flag - this will trigger cache key generation + const flag = await client.getFlag('test-flag'); + + // Flag won't be found but the cache key generation will have used the rules engine version + expect(flag).toBeNull(); + + client.close(); + }); + + test('should close gracefully', async () => { + await client.start(); + + client.close(); + + expect(mockDatastreamWSClientInstanceInstance.close).toHaveBeenCalled(); + expect(client.isConnected()).toBe(false); + }); + + test('should clear pending requests on disconnect', async () => { + mockDatastreamWSClientInstanceInstance.isConnected.mockReturnValue(true); + + // Mock sendMessage to not respond (simulating pending request) + mockDatastreamWSClientInstanceInstance.sendMessage.mockImplementation(() => { + // Don't send any response - leave the request pending + return Promise.resolve(); + }); + + await client.start(); + + const onCalls = mockDatastreamWSClientInstanceInstance.on.mock.calls; + const connectedHandler = onCalls.find(call => call[0] === 'connected')?.[1]; + if (connectedHandler) connectedHandler(); + + // Start a request that will be pending + const companyPromise = client.getCompany({ id: 'company-pending' }); + + // Give it a moment to register the pending request + await new Promise(resolve => process.nextTick(resolve)); + + // Now simulate disconnect to trigger cleanup + mockDatastreamWSClientInstanceInstance.isConnected.mockReturnValue(false); + const disconnectedHandler = onCalls.find(call => call[0] === 'disconnected')?.[1]; + if (disconnectedHandler) disconnectedHandler(); + + // Promise should reject due to cleanup (the actual error message is 'Company not found') + await expect(companyPromise).rejects.toThrow('Company not found'); + }); + + +}); \ No newline at end of file diff --git a/src/datastream/datastream-client.ts b/src/datastream/datastream-client.ts new file mode 100644 index 00000000..43fad387 --- /dev/null +++ b/src/datastream/datastream-client.ts @@ -0,0 +1,1266 @@ +import { EventEmitter } from 'events'; +import * as Schematic from '../api/types'; +import { DatastreamWSClient } from './websocket-client'; +import { DataStreamResp, DataStreamReq, EntityType, MessageType } from './types'; +import { RulesEngineClient } from '../rules-engine'; +import { Logger } from '../logger'; + +// Import cache providers from the cache module +import type { CacheProvider } from '../cache/types'; +import { LocalCache } from '../cache/local'; +import { RedisCacheProvider, type RedisOptions } from '../cache/redis'; + +/** + * Redis cache configuration options for DataStream client + */ +export interface DataStreamRedisConfig { + /** Redis connection URL (e.g., 'redis://localhost:6379') */ + url?: string; + /** Redis host (default: 'localhost') */ + host?: string; + /** Redis port (default: 6379) */ + port?: number; + /** Redis password */ + password?: string; + /** Redis database number (default: 0) */ + db?: number; + /** Redis key prefix for all cache keys (default: 'schematic:') */ + keyPrefix?: string; +} + +/** + * Options for configuring the DataStream client + */ +export interface DataStreamClientOptions { + /** Schematic API key for authentication */ + apiKey: string; + /** Base URL for the API (will be converted to WebSocket URL) */ + baseURL?: string; + /** Logger for debug/info/error messages */ + logger: Logger; + /** Cache TTL in milliseconds (default: 5 minutes) */ + cacheTTL?: number; + /** Redis configuration for all cache providers (if not provided, uses memory cache) */ + redisConfig?: DataStreamRedisConfig; + /** Custom cache provider for company entities (overrides Redis config if provided) */ + companyCache?: CacheProvider; + /** Custom cache provider for user entities (overrides Redis config if provided) */ + userCache?: CacheProvider; + /** Custom cache provider for flag entities (overrides Redis config if provided) */ + flagCache?: CacheProvider; + /** Enable replicator mode for external data synchronization */ + replicatorMode?: boolean; + /** Health check URL for replicator mode */ + replicatorHealthURL?: string; + /** Health check interval for replicator mode in milliseconds */ + replicatorHealthCheck?: number; +} + +/** + * Pending request handler type for companies and users + */ +type PendingRequestHandler = (value: T | null) => void; + +// Cache key constants +const CACHE_KEY_PREFIX = 'schematic'; +const CACHE_KEY_PREFIX_COMPANY = 'company'; +const CACHE_KEY_PREFIX_USER = 'user'; +const CACHE_KEY_PREFIX_FLAGS = 'flags'; +const RESOURCE_TIMEOUT = 30 * 1000; // 30 seconds +const DEFAULT_TTL = 24 * 60 * 60 * 1000; // 24 hours (matches Go defaultTTL) +const MAX_CACHE_TTL = 30 * 24 * 60 * 60 * 1000; // 30 days (matches Go maxCacheTTL) + +/** + * DataStreamClient provides a comprehensive client for Schematic's datastream + * with caching, flag evaluation, and entity management matching the Go implementation + */ +export class DataStreamClient extends EventEmitter { + private readonly apiKey: string; + private readonly baseURL?: string; + private readonly logger: Logger; + private readonly cacheTTL: number; + + // Cache providers + private readonly companyCacheProvider: CacheProvider; + private readonly userCacheProvider: CacheProvider; + private readonly flagsCacheProvider: CacheProvider; + + // WebSocket client + private wsClient?: DatastreamWSClient; + + // Rules engine for flag evaluation + private rulesEngine: RulesEngineClient; + + // Replicator mode configuration + private readonly replicatorMode: boolean; + private readonly replicatorHealthURL?: string; + private readonly replicatorHealthCheck: number; + private replicatorReady = false; + private replicatorHealthInterval?: NodeJS.Timeout; + private replicatorCacheVersion?: string; + + // Pending requests - maps cache key to array of handlers + private pendingCompanyRequests = new Map[]>(); + private pendingUserRequests = new Map[]>(); + private pendingFlagRequest?: PendingRequestHandler; + + constructor(options: DataStreamClientOptions) { + super(); + + this.apiKey = options.apiKey; + this.baseURL = options.baseURL; + this.logger = options.logger; + this.cacheTTL = options.cacheTTL ?? DEFAULT_TTL; + + // Initialize cache providers based on configuration + this.companyCacheProvider = this.createCacheProvider(options, 'company'); + this.userCacheProvider = this.createCacheProvider(options, 'user'); + this.flagsCacheProvider = this.createCacheProvider(options, 'flag'); + + // Replicator mode settings + this.replicatorMode = options.replicatorMode ?? false; + this.replicatorHealthURL = options.replicatorHealthURL; + this.replicatorHealthCheck = options.replicatorHealthCheck ?? 30 * 1000; // Default 30 seconds + + // Initialize rules engine + this.rulesEngine = new RulesEngineClient(); + } + + /** + * Creates cache providers based on configuration options + * Priority: custom cache provider > Redis config > memory cache + * Flag cache uses special TTL logic matching Go implementation + */ + private createCacheProvider(options: DataStreamClientOptions, cacheType: 'company' | 'user' | 'flag'): CacheProvider { + // Check for custom cache provider first + let customProvider: CacheProvider | undefined; + switch (cacheType) { + case 'company': + customProvider = options.companyCache as CacheProvider; + break; + case 'user': + customProvider = options.userCache as CacheProvider; + break; + case 'flag': + customProvider = options.flagCache as CacheProvider; + break; + } + + if (customProvider) { + return customProvider; + } + + // Calculate TTL based on cache type + const cacheTTL = this.calculateCacheTTL(cacheType); + + // Use Redis if configuration is provided + if (options.redisConfig) { + const redisOptions: RedisOptions = { + ...options.redisConfig, + ttl: cacheTTL, + keyPrefix: options.redisConfig.keyPrefix || 'schematic:' + }; + return new RedisCacheProvider(redisOptions); + } + + // Default to memory cache + return new LocalCache(); + } + + /** + * Calculates cache TTL based on cache type, matching Go implementation + * - Flag cache: use the greater of maxCacheTTL (30 days) or configured cacheTTL + * - Other caches: use configured cacheTTL (defaults to 24 hours) + */ + private calculateCacheTTL(cacheType: 'company' | 'user' | 'flag'): number { + if (cacheType === 'flag') { + // Flag TTL logic matches Go: use greater of maxCacheTTL or configured TTL + return Math.max(MAX_CACHE_TTL, this.cacheTTL); + } + return this.cacheTTL; + } + + /** + * Start initializes and starts the datastream client + */ + public async start(): Promise { + // Initialize rules engine first + try { + await this.rulesEngine.initialize(); + this.logger.debug('Rules engine initialized successfully'); + } catch (error) { + this.logger.warn(`Failed to initialize rules engine: ${error}`); + } + + // In replicator mode, we don't establish WebSocket connections + if (this.replicatorMode) { + this.logger.info('Replicator mode enabled - skipping WebSocket connection'); + if (this.replicatorHealthURL) { + this.startReplicatorHealthCheck(); + } + return; + } + + if (!this.baseURL) { + throw new Error('BaseURL is required when not in replicator mode'); + } + + this.logger.info('Starting DataStream client'); + + // Create WebSocket client + this.wsClient = new DatastreamWSClient({ + url: this.baseURL, + apiKey: this.apiKey, + logger: this.logger, + messageHandler: this.handleMessage.bind(this), + connectionReadyHandler: this.handleConnectionReady.bind(this), + }); + + // Set up event handlers + this.wsClient.on('connected', () => { + this.emit('connected'); + }); + + this.wsClient.on('disconnected', () => { + this.emit('disconnected'); + this.clearPendingRequests(); + }); + + this.wsClient.on('ready', () => { + this.emit('ready'); + }); + + this.wsClient.on('not-ready', () => { + this.emit('not-ready'); + }); + + this.wsClient.on('error', (error) => { + this.emit('error', error); + }); + + // Start WebSocket client + this.wsClient.start(); + } + + /** + * IsConnected returns whether the client is connected to the datastream + * In replicator mode, returns true if the external replicator is ready + */ + public isConnected(): boolean { + if (this.replicatorMode) { + return this.isReplicatorReady(); + } + + return this.wsClient?.isConnected() ?? false; + } + + /** + * GetCompany retrieves a company by keys, using cache or datastream + */ + public async getCompany(keys: Record): Promise { + // Check cache first for any of the keys + const cached = await this.getCompanyFromCache(keys); + if (cached) { + this.logger.debug(`Company found in cache for keys: ${JSON.stringify(keys)}`); + return cached; + } + + // Handle replicator mode behavior - in replicator mode, only use cached data + if (this.replicatorMode) { + throw new Error('Company not found in cache and replicator mode is enabled'); + } + + // If not in cache and not connected, throw error + if (!this.isConnected()) { + throw new Error('DataStream client is not connected'); + } + + // Check if there's already a pending request for any of these keys + const cacheKeys = this.generateCacheKeysForCompany(keys); + let existingRequest = false; + + for (const cacheKey of cacheKeys) { + if (this.pendingCompanyRequests.has(cacheKey)) { + existingRequest = true; + break; + } + } + + return new Promise((resolve, reject) => { + const timeout = setTimeout(() => { + this.cleanupPendingCompanyRequests(cacheKeys, handler); + reject(new Error('Timeout while waiting for company data')); + }, RESOURCE_TIMEOUT); + + const handler: PendingRequestHandler = (company) => { + clearTimeout(timeout); + if (company) { + resolve(company); + } else { + reject(new Error('Company not found')); + } + }; + + // Add handler to all cache keys + for (const cacheKey of cacheKeys) { + if (!this.pendingCompanyRequests.has(cacheKey)) { + this.pendingCompanyRequests.set(cacheKey, []); + } + this.pendingCompanyRequests.get(cacheKey)!.push(handler); + } + + // Only send request if there wasn't already one pending + if (!existingRequest) { + this.sendDataStreamRequest({ + entity_type: EntityType.COMPANY, + keys, + }).catch((error) => { + this.cleanupPendingCompanyRequests(cacheKeys, handler); + reject(error); + }); + } + }); + } + + /** + * GetUser retrieves a user by keys, using cache or datastream + */ + public async getUser(keys: Record): Promise { + // Check cache first for any of the keys + const cached = await this.getUserFromCache(keys); + if (cached) { + this.logger.debug(`User found in cache for keys: ${JSON.stringify(keys)}`); + return cached; + } + + // Handle replicator mode behavior - in replicator mode, only use cached data + if (this.replicatorMode) { + throw new Error('User not found in cache and replicator mode is enabled'); + } + + // If not in cache and not connected, throw error + if (!this.isConnected()) { + throw new Error('DataStream client is not connected'); + } + + // Check if there's already a pending request for any of these keys + const cacheKeys = this.generateCacheKeysForUser(keys); + let existingRequest = false; + + for (const cacheKey of cacheKeys) { + if (this.pendingUserRequests.has(cacheKey)) { + existingRequest = true; + break; + } + } + + return new Promise((resolve, reject) => { + const timeout = setTimeout(() => { + this.cleanupPendingUserRequests(cacheKeys, handler); + reject(new Error('Timeout while waiting for user data')); + }, RESOURCE_TIMEOUT); + + const handler: PendingRequestHandler = (user) => { + clearTimeout(timeout); + if (user) { + resolve(user); + } else { + reject(new Error('User not found')); + } + }; + + // Add handler to all cache keys + for (const cacheKey of cacheKeys) { + if (!this.pendingUserRequests.has(cacheKey)) { + this.pendingUserRequests.set(cacheKey, []); + } + this.pendingUserRequests.get(cacheKey)!.push(handler); + } + + // Only send request if there wasn't already one pending + if (!existingRequest) { + this.sendDataStreamRequest({ + entity_type: EntityType.USER, + keys, + }).catch((error) => { + this.cleanupPendingUserRequests(cacheKeys, handler); + reject(error); + }); + } + }); + } + + /** + * GetFlag retrieves a flag by key from cache + */ + public async getFlag(flagKey: string): Promise { + const cacheKey = this.flagCacheKey(flagKey); + this.logger.debug(`Retrieving flag from cache: ${flagKey} (cache key: ${cacheKey})`); + try { + const result = await this.flagsCacheProvider.get(cacheKey); + return result || null; + } catch (error) { + this.logger.warn(`Failed to retrieve flag from cache: ${error}`); + return null; + } + } + + /** + * GetAllFlags requests a refresh of all flags from the datastream + */ + public async getAllFlags(): Promise { + // Check if there is already a pending request for flags + if (this.pendingFlagRequest) { + return new Promise((resolve, reject) => { + // Wait for existing request to complete + const originalHandler = this.pendingFlagRequest!; + this.pendingFlagRequest = (success: boolean | null) => { + originalHandler(success); + if (success) { + resolve(); + } else { + reject(new Error('Failed to refresh flags')); + } + }; + }); + } + + return new Promise((resolve, reject) => { + const timeout = setTimeout(() => { + this.pendingFlagRequest = undefined; + reject(new Error('Timeout while waiting for flags data')); + }, RESOURCE_TIMEOUT); + + this.pendingFlagRequest = (success: boolean | null) => { + clearTimeout(timeout); + this.pendingFlagRequest = undefined; + if (success) { + resolve(); + } else { + reject(new Error('Failed to refresh flags')); + } + }; + + this.sendDataStreamRequest({ + entity_type: EntityType.FLAGS, + }).catch((error) => { + clearTimeout(timeout); + this.pendingFlagRequest = undefined; + reject(error); + }); + }); + } + + /** + * CheckFlag evaluates a flag for a company and/or user context + */ + public async checkFlag( + evalCtx: { company?: Record; user?: Record }, + flagKey: string + ): Promise { + // Get flag first - return error if not found + const flag = await this.getFlag(flagKey); + if (!flag) { + throw new Error(`Flag not found: ${flagKey}`); + } + + const needsCompany = evalCtx.company && Object.keys(evalCtx.company).length > 0; + const needsUser = evalCtx.user && Object.keys(evalCtx.user).length > 0; + + let cachedCompany: Schematic.RulesengineCompany | null = null; + let cachedUser: Schematic.RulesengineUser | null = null; + + // Try to get cached data first + if (needsCompany) { + cachedCompany = await this.getCompanyFromCache(evalCtx.company!); + this.logger.debug(`Company ${cachedCompany ? 'found in cache' : 'not found in cache'} for keys: ${JSON.stringify(evalCtx.company)}`); + } + if (needsUser) { + cachedUser = await this.getUserFromCache(evalCtx.user!); + this.logger.debug(`User ${cachedUser ? 'found in cache' : 'not found in cache'} for keys: ${JSON.stringify(evalCtx.user)}`); + } + + // Handle replicator mode behavior + if (this.replicatorMode) { + // In replicator mode, if we don't have all cached data, evaluate with null values instead of fetching + // The external replicator should have populated the cache with all necessary data + return this.evaluateFlag(flag, cachedCompany, cachedUser); + } + + // Non-replicator mode: if we have all cached data we need, use it + if ((!needsCompany || cachedCompany) && (!needsUser || cachedUser)) { + this.logger.debug(`All required resources found in cache for flag ${flagKey} evaluation`); + return this.evaluateFlag(flag, cachedCompany, cachedUser); + } + + // Check if we're connected to datastream for live fetching + if (!this.isConnected()) { + throw new Error('Datastream not connected and required entities not in cache'); + } + + // Fetch missing data from datastream + let company: Schematic.RulesengineCompany | null = null; + let user: Schematic.RulesengineUser | null = null; + + if (needsCompany) { + if (cachedCompany) { + company = cachedCompany; + this.logger.debug(`Using cached company data for keys: ${JSON.stringify(evalCtx.company)}`); + } else { + this.logger.debug(`Fetching company from datastream for keys: ${JSON.stringify(evalCtx.company)}`); + company = await this.getCompany(evalCtx.company!); + } + } + + if (needsUser) { + if (cachedUser) { + user = cachedUser; + this.logger.debug(`Using cached user data for keys: ${JSON.stringify(evalCtx.user)}`); + } else { + this.logger.debug(`Fetching user from datastream for keys: ${JSON.stringify(evalCtx.user)}`); + user = await this.getUser(evalCtx.user!); + } + } + + // Evaluate against the rules engine + return this.evaluateFlag(flag, company, user); + } + + /** + * UpdateCompanyMetrics updates company metrics locally (for track events) + */ + public async updateCompanyMetrics(keys: Record, event: string, quantity: number): Promise { + const company = await this.getCompanyFromCache(keys); + if (!company) { + return; // No company in cache to update + } + + // Create a deep copy to avoid modifying the cached object + const updatedCompany = this.deepCopyCompany(company); + + // Update the metric value if it matches the event + if (updatedCompany.metrics) { + for (const metric of updatedCompany.metrics) { + if (metric?.eventSubtype === event) { + metric.value = (metric.value || 0) + quantity; + } + } + } + + // Update cache with the modified company + await this.cacheCompanyForKeys(updatedCompany); + } + + /** + * Close gracefully closes the datastream client + */ + public close(): void { + this.logger.info('Closing DataStream client'); + + // Stop replicator health checks + if (this.replicatorHealthInterval) { + clearInterval(this.replicatorHealthInterval); + this.replicatorHealthInterval = undefined; + } + + // Clear all pending requests + this.clearPendingRequests(); + + // Close WebSocket client + if (this.wsClient) { + this.wsClient.close(); + this.wsClient = undefined; + } + + this.logger.info('DataStream client closed'); + } + + /** + * IsReplicatorReady returns whether the external replicator is ready + */ + public isReplicatorReady(): boolean { + return this.replicatorReady; + } + + /** + * IsReplicatorMode returns whether the client is running in replicator mode + */ + public isReplicatorMode(): boolean { + return this.replicatorMode; + } + + /** + * GetReplicatorCacheVersion returns the current cache version from the replicator + */ + public getReplicatorCacheVersion(): string | undefined { + return this.replicatorCacheVersion; + } + + /** + * GetReplicatorCacheVersionAsync attempts to fetch cache version immediately if not available + */ + public async getReplicatorCacheVersionAsync(timeoutMs = 2000): Promise { + // If we already have a cache version, return it immediately + if (this.replicatorCacheVersion) { + return this.replicatorCacheVersion; + } + + // If we don't have a cache version yet and we're in replicator mode, try to get it + if (this.replicatorMode && this.replicatorHealthURL) { + try { + const controller = new AbortController(); + const timeoutId = setTimeout(() => controller.abort(), timeoutMs); + + const response = await fetch(this.replicatorHealthURL, { + method: 'GET', + signal: controller.signal, + }); + + clearTimeout(timeoutId); + + if (response.ok) { + const healthData = await response.json() as { ready?: boolean; cache_version?: string; cacheVersion?: string }; + const newCacheVersion = healthData.cache_version || healthData.cacheVersion; + if (newCacheVersion) { + this.replicatorCacheVersion = newCacheVersion; + return newCacheVersion; + } + } + } catch (error) { + this.logger.debug(`Failed to fetch replicator cache version: ${error}`); + } + } + + return undefined; + } + + /** + * handleMessage processes incoming datastream messages + */ + private async handleMessage(ctx: any, message: DataStreamResp): Promise { + this.logger.debug(`Processing datastream message: EntityType=${message.entity_type}, MessageType=${message.message_type}`); + + try { + if (message.message_type === MessageType.ERROR) { + await this.handleErrorMessage(message); + return; + } + + switch (message.entity_type) { + case EntityType.COMPANY: + case EntityType.COMPANIES: + await this.handleCompanyMessage(message); + break; + case EntityType.USER: + case EntityType.USERS: + await this.handleUserMessage(message); + break; + case EntityType.FLAGS: + await this.handleFlagsMessage(message); + break; + case EntityType.FLAG: + await this.handleFlagMessage(message); + break; + default: + this.logger.warn(`Unknown entity type in datastream message: ${message.entity_type}`); + } + } catch (error) { + this.logger.error(`Error processing datastream message: ${error}`); + this.emit('error', error); + } + } + + /** + * handleCompanyMessage processes company-specific datastream messages + */ + private async handleCompanyMessage(message: DataStreamResp): Promise { + const company = message.data as Schematic.RulesengineCompany; + + if (!company) { + return; + } + + if (message.message_type === MessageType.DELETE) { + // Remove company from cache + if (company.keys) { + for (const [key, value] of Object.entries(company.keys)) { + const cacheKey = this.resourceKeyToCacheKey(CACHE_KEY_PREFIX_COMPANY, key, value); + try { + await this.companyCacheProvider.delete(cacheKey); + } catch (error) { + this.logger.warn(`Failed to delete company from cache: ${error}`); + } + } + } + return; + } + + // Cache the company + await this.cacheCompanyForKeys(company); + + // Notify pending requests + this.notifyPendingCompanyRequests(company.keys || {}, company); + } + + /** + * handleUserMessage processes user-specific datastream messages + */ + private async handleUserMessage(message: DataStreamResp): Promise { + const user = message.data as Schematic.RulesengineUser; + + if (!user) { + return; + } + + if (message.message_type === MessageType.DELETE) { + // Remove user from cache + if (user.keys) { + for (const [key, value] of Object.entries(user.keys)) { + const cacheKey = this.resourceKeyToCacheKey(CACHE_KEY_PREFIX_USER, key, value); + try { + await this.userCacheProvider.delete(cacheKey); + } catch (error) { + this.logger.warn(`Failed to delete user from cache: ${error}`); + } + } + } + return; + } + + // Cache the user + if (user.keys) { + for (const [key, value] of Object.entries(user.keys)) { + const cacheKey = this.resourceKeyToCacheKey(CACHE_KEY_PREFIX_USER, key, value); + try { + await this.userCacheProvider.set(cacheKey, user, this.cacheTTL); + } catch (error) { + this.logger.warn(`Failed to cache user: ${error}`); + } + } + } + + // Notify pending requests + this.notifyPendingUserRequests(user.keys || {}, user); + } + + /** + * handleFlagsMessage processes bulk flags messages + */ + private async handleFlagsMessage(message: DataStreamResp): Promise { + const flags = message.data as Schematic.RulesengineFlag[]; + + if (!Array.isArray(flags)) { + this.logger.warn('Expected flags array in bulk flags message'); + return; + } + + const cacheKeys: string[] = []; + for (const flag of flags) { + if (flag?.key) { + const cacheKey = this.flagCacheKey(flag.key); + try { + await this.flagsCacheProvider.set(cacheKey, flag); + cacheKeys.push(cacheKey); + } catch (error) { + this.logger.warn(`Failed to cache flag: ${error}`); + } + } + } + + // Delete flags not in the response + if (this.flagsCacheProvider.deleteMissing) { + try { + // Only scan flag keys (flags:*) for better performance + await this.flagsCacheProvider.deleteMissing(cacheKeys, { scanPattern: 'flags:*' }); + } catch (error) { + this.logger.warn(`Failed to delete missing flags: ${error}`); + } + } + + // Notify pending flag request + if (this.pendingFlagRequest) { + this.pendingFlagRequest(true); + } + } + + /** + * handleFlagMessage processes single flag messages + */ + private async handleFlagMessage(message: DataStreamResp): Promise { + const flag = message.data as Schematic.RulesengineFlag; + + if (!flag?.key) { + return; + } + + const cacheKey = this.flagCacheKey(flag.key); + + try { + switch (message.message_type) { + case MessageType.DELETE: + await this.flagsCacheProvider.delete(cacheKey); + break; + case MessageType.FULL: + await this.flagsCacheProvider.set(cacheKey, flag); + break; + default: + this.logger.warn(`Unhandled message type for flag: ${message.message_type}`); + break; + } + } catch (error) { + this.logger.warn(`Failed to update flag cache: ${error}`); + } + + // Notify pending flag request + if (this.pendingFlagRequest) { + this.pendingFlagRequest(true); + } + } + + /** + * handleErrorMessage processes error messages + */ + private async handleErrorMessage(message: DataStreamResp): Promise { + const errorData = message.data as any; + + if (errorData?.keys && errorData?.entity_type) { + // Notify pending requests with null/error + switch (errorData.entity_type) { + case EntityType.COMPANY: + this.notifyPendingCompanyRequests(errorData.keys, null); + break; + case EntityType.USER: + this.notifyPendingUserRequests(errorData.keys, null); + break; + default: + this.logger.warn(`Received error for unsupported entity type: ${errorData.entity_type}`); + } + } + + // Log the error but don't emit error event - just continue processing like Go implementation + const errorMessage = errorData?.error || 'Unknown datastream error'; + this.logger.warn(`DataStream error received: ${errorMessage}`); + } + + /** + * handleConnectionReady is called when the WebSocket connection is ready + */ + private async handleConnectionReady(ctx: any): Promise { + this.logger.info('DataStream connection is ready'); + + // Request initial flag data + try { + await this.getAllFlags(); + this.logger.debug('Requested initial flag data'); + } catch (error) { + this.logger.error(`Failed to request initial flag data: ${error}`); + throw error; + } + } + + /** + * sendDataStreamRequest sends a request to the datastream + */ + private async sendDataStreamRequest(request: DataStreamReq): Promise { + if (!this.wsClient || !this.wsClient.isConnected()) { + throw new Error('DataStream client is not connected'); + } + + this.logger.debug(`Sending datastream request: EntityType=${request.entity_type}, Keys=${JSON.stringify(request.keys)}`); + + // Package the message like the Go implementation + const packagedMessage = { + data: request + }; + + await this.wsClient.sendMessage(packagedMessage); + } + + /** + * getCompanyFromCache attempts to retrieve a company from cache using any of the provided keys + */ + private async getCompanyFromCache(keys: Record): Promise { + for (const [key, value] of Object.entries(keys)) { + const cacheKey = this.resourceKeyToCacheKey(CACHE_KEY_PREFIX_COMPANY, key, value); + try { + const company = await this.companyCacheProvider.get(cacheKey); + if (company) { + return company; + } + } catch (error) { + this.logger.warn(`Failed to retrieve company from cache: ${error}`); + } + } + return null; + } + + /** + * getUserFromCache attempts to retrieve a user from cache using any of the provided keys + */ + private async getUserFromCache(keys: Record): Promise { + for (const [key, value] of Object.entries(keys)) { + const cacheKey = this.resourceKeyToCacheKey(CACHE_KEY_PREFIX_USER, key, value); + try { + const user = await this.userCacheProvider.get(cacheKey); + if (user) { + return user; + } + } catch (error) { + this.logger.warn(`Failed to retrieve user from cache: ${error}`); + } + } + return null; + } + + /** + * cacheCompanyForKeys caches a company for all of its keys + */ + private async cacheCompanyForKeys(company: Schematic.RulesengineCompany): Promise { + if (!company.keys || Object.keys(company.keys).length === 0) { + throw new Error('No keys provided for company lookup'); + } + + for (const [key, value] of Object.entries(company.keys)) { + const cacheKey = this.resourceKeyToCacheKey(CACHE_KEY_PREFIX_COMPANY, key, value); + try { + await this.companyCacheProvider.set(cacheKey, company, this.cacheTTL); + } catch (error) { + this.logger.warn(`Failed to cache company for key '${cacheKey}': ${error}`); + } + } + } + + /** + * generateCacheKeysForCompany generates all cache keys for a company's keys + */ + private generateCacheKeysForCompany(keys: Record): string[] { + return Object.entries(keys).map(([key, value]) => + this.resourceKeyToCacheKey(CACHE_KEY_PREFIX_COMPANY, key, value) + ); + } + + /** + * generateCacheKeysForUser generates all cache keys for a user's keys + */ + private generateCacheKeysForUser(keys: Record): string[] { + return Object.entries(keys).map(([key, value]) => + this.resourceKeyToCacheKey(CACHE_KEY_PREFIX_USER, key, value) + ); + } + + /** + * notifyPendingCompanyRequests notifies all pending company requests + */ + private notifyPendingCompanyRequests(keys: Record, company: Schematic.RulesengineCompany | null): void { + for (const [key, value] of Object.entries(keys)) { + const cacheKey = this.resourceKeyToCacheKey(CACHE_KEY_PREFIX_COMPANY, key, value); + const handlers = this.pendingCompanyRequests.get(cacheKey); + if (handlers) { + this.pendingCompanyRequests.delete(cacheKey); + handlers.forEach(handler => { + try { + handler(company); + } catch (error) { + this.logger.error(`Error in company request handler: ${error}`); + } + }); + } + } + } + + /** + * notifyPendingUserRequests notifies all pending user requests + */ + private notifyPendingUserRequests(keys: Record, user: Schematic.RulesengineUser | null): void { + for (const [key, value] of Object.entries(keys)) { + const cacheKey = this.resourceKeyToCacheKey(CACHE_KEY_PREFIX_USER, key, value); + const handlers = this.pendingUserRequests.get(cacheKey); + if (handlers) { + this.pendingUserRequests.delete(cacheKey); + handlers.forEach(handler => { + try { + handler(user); + } catch (error) { + this.logger.error(`Error in user request handler: ${error}`); + } + }); + } + } + } + + /** + * cleanupPendingCompanyRequests removes a specific handler from pending company requests + */ + private cleanupPendingCompanyRequests(cacheKeys: string[], handler: PendingRequestHandler): void { + for (const cacheKey of cacheKeys) { + const handlers = this.pendingCompanyRequests.get(cacheKey); + if (handlers) { + const index = handlers.indexOf(handler); + if (index !== -1) { + handlers.splice(index, 1); + } + if (handlers.length === 0) { + this.pendingCompanyRequests.delete(cacheKey); + } + } + } + } + + /** + * cleanupPendingUserRequests removes a specific handler from pending user requests + */ + private cleanupPendingUserRequests(cacheKeys: string[], handler: PendingRequestHandler): void { + for (const cacheKey of cacheKeys) { + const handlers = this.pendingUserRequests.get(cacheKey); + if (handlers) { + const index = handlers.indexOf(handler); + if (index !== -1) { + handlers.splice(index, 1); + } + if (handlers.length === 0) { + this.pendingUserRequests.delete(cacheKey); + } + } + } + } + + /** + * clearPendingRequests clears all pending requests + */ + private clearPendingRequests(): void { + // Clear company requests + for (const [, handlers] of this.pendingCompanyRequests) { + handlers.forEach(handler => { + try { + handler(null); + } catch (error) { + this.logger.error(`Error clearing company request: ${error}`); + } + }); + } + this.pendingCompanyRequests.clear(); + + // Clear user requests + for (const [, handlers] of this.pendingUserRequests) { + handlers.forEach(handler => { + try { + handler(null); + } catch (error) { + this.logger.error(`Error clearing user request: ${error}`); + } + }); + } + this.pendingUserRequests.clear(); + + // Clear flag request + if (this.pendingFlagRequest) { + try { + this.pendingFlagRequest(false); + } catch (error) { + this.logger.error(`Error clearing flag request: ${error}`); + } + this.pendingFlagRequest = undefined; + } + } + + /** + * startReplicatorHealthCheck starts periodic health checks for replicator mode + */ + private startReplicatorHealthCheck(): void { + if (!this.replicatorHealthURL) { + return; + } + + this.logger.info(`Starting replicator health check with URL: ${this.replicatorHealthURL}, interval: ${this.replicatorHealthCheck}ms`); + + // Initial health check + this.checkReplicatorHealth(); + + // Set up periodic health checks + this.replicatorHealthInterval = setInterval(() => { + this.checkReplicatorHealth(); + }, this.replicatorHealthCheck); + } + + /** + * checkReplicatorHealth performs a single health check against the external replicator + */ + private async checkReplicatorHealth(): Promise { + if (!this.replicatorHealthURL) { + return; + } + + try { + const response = await fetch(this.replicatorHealthURL, { + method: 'GET', + // @ts-ignore - timeout is supported in newer Node.js versions + timeout: 5000, + }); + + if (!response.ok) { + throw new Error(`HTTP ${response.status}: ${response.statusText}`); + } + + const healthData = await response.json() as { ready?: boolean; cache_version?: string; cacheVersion?: string }; + const wasReady = this.replicatorReady; + this.replicatorReady = healthData.ready ?? false; + + // Extract cache version from response if available + const newCacheVersion = healthData.cache_version || healthData.cacheVersion; + if (newCacheVersion && newCacheVersion !== this.replicatorCacheVersion) { + const oldVersion = this.replicatorCacheVersion; + this.replicatorCacheVersion = newCacheVersion; + this.logger.info(`Cache version changed from ${oldVersion || '(null)'} to ${newCacheVersion}`); + } + + // Log state changes + if (this.replicatorReady && !wasReady) { + this.logger.info('External replicator is now ready'); + this.emit('replicator-health-changed', true); + } else if (!this.replicatorReady && wasReady) { + this.logger.info('External replicator is no longer ready'); + this.emit('replicator-health-changed', false); + } + } catch (error) { + if (this.replicatorReady) { + this.replicatorReady = false; + this.logger.info('External replicator is no longer ready'); + this.emit('replicator-health-changed', false); + } + this.logger.debug(`Replicator health check failed: ${error}`); + } + } + + /** + * flagCacheKey generates a cache key for a flag + */ + private flagCacheKey(key: string): string { + // Use replicator cache version if available, otherwise use rules engine version + const versionKey = this.replicatorMode && this.replicatorCacheVersion + ? this.replicatorCacheVersion + : this.getRulesEngineVersionKey(); + + const cacheKey = `${CACHE_KEY_PREFIX_FLAGS}:${versionKey}:${key.toLowerCase()}`; + + this.logger.debug(`Generated flag cache key - flag: ${key}, mode: ${this.replicatorMode ? 'replicator' : 'datastream'}, version: ${versionKey}, cacheKey: ${cacheKey}`); + + return cacheKey; + } + + /** + * resourceKeyToCacheKey generates a cache key for a resource + */ + private resourceKeyToCacheKey(resourceType: string, key: string, value: string): string { + // Use replicator cache version if available, otherwise use rules engine version + const versionKey = this.replicatorMode && this.replicatorCacheVersion + ? this.replicatorCacheVersion + : this.getRulesEngineVersionKey(); + return `${resourceType}:${versionKey}:${key.toLowerCase()}:${value.toLowerCase()}`; + } + + /** + * deepCopyCompany creates a complete deep copy of a Company struct + */ + private deepCopyCompany(company: Schematic.RulesengineCompany): Schematic.RulesengineCompany { + // Use JSON parsing for a deep copy - this matches the Go implementation approach + return JSON.parse(JSON.stringify(company)); + } + + /** + * evaluateFlag evaluates a flag using the rules engine + */ + private sanitizeForWasm(obj: any): any { + if (obj === null || obj === undefined) { + return null; + } + + if (Array.isArray(obj)) { + return obj.map(item => this.sanitizeForWasm(item)).filter(item => item !== null); + } + + if (typeof obj === 'object') { + const sanitized: any = {}; + for (const [key, value] of Object.entries(obj)) { + const sanitizedValue = this.sanitizeForWasm(value); + if (sanitizedValue !== null) { + sanitized[key] = sanitizedValue; + } + } + return sanitized; + } + + return obj; + } + + private async evaluateFlag( + flag: Schematic.RulesengineFlag, + company: Schematic.RulesengineCompany | null, + user: Schematic.RulesengineUser | null + ): Promise { + try { + // Use rules engine if initialized + if (this.rulesEngine.isInitialized()) { + this.logger.debug(`Evaluating flag with rules engine: ${JSON.stringify({ flagId: flag.id, flagRules: flag.rules?.length || 0, companyId: company?.id, userId: user?.id })}`); + + // Sanitize flag data for WASM - ensure no null values in required arrays + const sanitizedFlag = this.sanitizeForWasm(flag); + if (!sanitizedFlag.rules) { + sanitizedFlag.rules = []; + } + + // Sanitize company and user data as well + const sanitizedCompany = company ? this.sanitizeForWasm(company) : null; + const sanitizedUser = user ? this.sanitizeForWasm(user) : null; + + const result = await this.rulesEngine.checkFlag(sanitizedFlag, sanitizedCompany, sanitizedUser); + this.logger.debug(`Rules engine evaluation result: ${JSON.stringify(result)}`); + return { + flagKey: flag.key, + value: result.value ?? flag.defaultValue, + reason: result.reason || 'RULES_ENGINE_EVALUATION', + companyId: company?.id, + userId: user?.id, + flagId: flag.id, + ruleId: result.ruleId + }; + } else { + // Fallback to default value if rules engine not available + this.logger.warn('Rules engine not initialized, using default flag value'); + return { + flagKey: flag.key, + value: flag.defaultValue, + reason: 'RULES_ENGINE_UNAVAILABLE', + companyId: company?.id, + userId: user?.id, + flagId: flag.id + }; + } + } catch (error) { + this.logger.error(`Rules engine evaluation failed: ${error}`); + // Fallback to default value on error + return { + flagKey: flag.key, + value: flag.defaultValue, + reason: 'RULES_ENGINE_ERROR', + companyId: company?.id, + userId: user?.id, + flagId: flag.id + }; + } + } + + /** + * getRulesEngineVersionKey gets the version key from the rules engine + */ + private getRulesEngineVersionKey(): string { + try { + if (this.rulesEngine.isInitialized()) { + return this.rulesEngine.getVersionKey(); + } + } catch (error) { + this.logger.warn(`Failed to get rules engine version key: ${error}`); + } + // Fallback to '1' if rules engine is not available or fails + return '1'; + } +} \ No newline at end of file diff --git a/src/datastream/index.ts b/src/datastream/index.ts new file mode 100644 index 00000000..3b846558 --- /dev/null +++ b/src/datastream/index.ts @@ -0,0 +1,8 @@ +// Main datastream client for external use +export { + DataStreamClient +} from './datastream-client'; +export type { + DataStreamClientOptions, + DataStreamRedisConfig, +} from './datastream-client'; diff --git a/src/datastream/types.ts b/src/datastream/types.ts new file mode 100644 index 00000000..3370a063 --- /dev/null +++ b/src/datastream/types.ts @@ -0,0 +1,54 @@ +/** + * Datastream message types for WebSocket communication + */ +export type Action = "start" | "stop"; + +export enum EntityType { + COMPANY = "rulesengine.Company", + COMPANIES = "rulesengine.Companies", + USER = "rulesengine.User", + USERS = "rulesengine.Users", + FLAG = "rulesengine.Flag", + FLAGS = "rulesengine.Flags", +} + +export enum MessageType { + FULL = "full", + PARTIAL = "partial", + DELETE = "delete", + ERROR = "error", + UNKNOWN = "unknown", +} + +/** + * DataStreamReq represents a request message to the datastream + */ +export interface DataStreamReq { + entity_type: EntityType; + keys?: Record; +} + +/** + * DataStreamBaseReq wraps the request data + */ +export interface DataStreamBaseReq { + data: DataStreamReq; +} + +/** + * DataStreamResp represents a response message from the datastream + */ +export interface DataStreamResp { + data: any; // JSON raw message equivalent + entity_type: string; + message_type: string; +} + +/** + * DataStreamError represents an error message from the datastream + */ +export interface DataStreamError { + error: string; + keys?: Record; + entity_type?: EntityType; +} \ No newline at end of file diff --git a/src/datastream/websocket-client.test.ts b/src/datastream/websocket-client.test.ts new file mode 100644 index 00000000..f860fcb2 --- /dev/null +++ b/src/datastream/websocket-client.test.ts @@ -0,0 +1,182 @@ +import { DatastreamWSClient, MessageHandlerFunc, ConnectionReadyHandlerFunc } from './websocket-client'; +import { DataStreamResp } from './types'; +import { Logger } from '../logger'; + +// Mock logger implementation +class MockLogger implements Logger { + debug(ctx: any, message: string, ...args: any[]): void { + console.log(`[DEBUG] ${message}`, ...args); + } + + info(ctx: any, message: string, ...args: any[]): void { + console.log(`[INFO] ${message}`, ...args); + } + + warn(ctx: any, message: string, ...args: any[]): void { + console.log(`[WARN] ${message}`, ...args); + } + + error(ctx: any, message: string, ...args: any[]): void { + console.error(`[ERROR] ${message}`, ...args); + } +} + +describe('DatastreamWSClient', () => { + let client: DatastreamWSClient; + const mockLogger = new MockLogger(); + + const mockMessageHandler: MessageHandlerFunc = async (ctx: any, message: DataStreamResp) => { + console.log('Received message:', message); + }; + + const mockConnectionReadyHandler: ConnectionReadyHandlerFunc = async (ctx: any) => { + console.log('Connection ready'); + }; + + afterEach(() => { + if (client) { + client.close(); + } + }); + + test('should create client with required options', () => { + expect(() => { + client = new DatastreamWSClient({ + url: 'wss://test.example.com/datastream', + apiKey: 'test-api-key', + messageHandler: mockMessageHandler, + logger: mockLogger, + }); + }).not.toThrow(); + + expect(client.isConnected()).toBe(false); + expect(client.isReady()).toBe(false); + }); + + test('should throw error when URL is missing', () => { + expect(() => { + new DatastreamWSClient({ + url: '', + apiKey: 'test-key', + messageHandler: mockMessageHandler, + logger: mockLogger, + }); + }).toThrow('URL is required'); + }); + + test('should throw error when API key is missing', () => { + expect(() => { + new DatastreamWSClient({ + url: 'wss://example.com', + apiKey: '', + messageHandler: mockMessageHandler, + logger: mockLogger, + }); + }).toThrow('ApiKey is required'); + }); + + test('should throw error when message handler is missing', () => { + expect(() => { + new DatastreamWSClient({ + url: 'wss://example.com', + apiKey: 'test-key', + messageHandler: undefined as any, + logger: mockLogger, + }); + }).toThrow('MessageHandler is required'); + }); + + test('should convert HTTP URL to WebSocket URL', () => { + client = new DatastreamWSClient({ + url: 'https://api.schematichq.com', + apiKey: 'test-key', + messageHandler: mockMessageHandler, + logger: mockLogger, + }); + + // The URL conversion is tested internally - we can't directly access the private url property + // But we can verify the client was created successfully + expect(client).toBeDefined(); + expect(client.isConnected()).toBe(false); + }); + + test('should convert HTTP localhost URL to WebSocket URL', () => { + client = new DatastreamWSClient({ + url: 'http://localhost:8080', + apiKey: 'test-key', + messageHandler: mockMessageHandler, + logger: mockLogger, + }); + + expect(client).toBeDefined(); + expect(client.isConnected()).toBe(false); + }); + + test('should handle WebSocket URL directly', () => { + client = new DatastreamWSClient({ + url: 'wss://datastream.example.com/datastream', + apiKey: 'test-key', + messageHandler: mockMessageHandler, + logger: mockLogger, + }); + + expect(client).toBeDefined(); + expect(client.isConnected()).toBe(false); + }); + + test('should set default options when not provided', () => { + client = new DatastreamWSClient({ + url: 'wss://example.com', + apiKey: 'test-key', + messageHandler: mockMessageHandler, + logger: mockLogger, + }); + + // Defaults are applied internally - we verify by successful construction + expect(client).toBeDefined(); + }); + + test('should use custom options when provided', () => { + client = new DatastreamWSClient({ + url: 'wss://example.com', + apiKey: 'test-key', + messageHandler: mockMessageHandler, + connectionReadyHandler: mockConnectionReadyHandler, + logger: mockLogger, + maxReconnectAttempts: 5, + minReconnectDelay: 2000, + maxReconnectDelay: 60000, + }); + + expect(client).toBeDefined(); + }); + + test('should emit events', (done) => { + client = new DatastreamWSClient({ + url: 'wss://example.com', + apiKey: 'test-key', + messageHandler: mockMessageHandler, + logger: mockLogger, + }); + + // Test that the client can emit events + client.on('error', (error: any) => { + expect(error).toBeDefined(); + done(); + }); + + // Trigger an error to test event emission + client.emit('error', new Error('Test error')); + }); + + test('should reject sendMessage when not connected', async () => { + client = new DatastreamWSClient({ + url: 'wss://example.com', + apiKey: 'test-key', + messageHandler: mockMessageHandler, + logger: mockLogger, + }); + + await expect(client.sendMessage({ test: 'message' })).rejects.toThrow('WebSocket connection is not available!'); + }); +}); \ No newline at end of file diff --git a/src/datastream/websocket-client.ts b/src/datastream/websocket-client.ts new file mode 100644 index 00000000..3308b571 --- /dev/null +++ b/src/datastream/websocket-client.ts @@ -0,0 +1,572 @@ +// Note: This client is designed for Node.js server environments only +// The ws package is required and provides the WebSocket implementation + +import { EventEmitter } from 'events'; +import { DataStreamResp } from './types'; +import { Logger } from '../logger'; + +// Dynamic imports to avoid webpack issues +const createWebSocket = () => { + try { + const WebSocketClass = require('ws'); + return WebSocketClass; + } catch (e) { + throw new Error('WebSocket client requires Node.js environment with ws package installed: npm install ws'); + } +}; + +const createURL = () => { + try { + return require('url').URL; + } catch (e) { + throw new Error('URL implementation not available in this environment'); + } +}; + +/** + * WebSocket configuration constants + */ +const WRITE_WAIT = 10 * 1000; // 10 seconds in milliseconds +const PONG_WAIT = 60 * 1000; // 60 seconds +const PING_PERIOD = (PONG_WAIT * 9) / 10; +const MAX_RECONNECT_ATTEMPTS = 10; +const MIN_RECONNECT_DELAY = 1 * 1000; // 1 second +const MAX_RECONNECT_DELAY = 30 * 1000; // 30 seconds + +/** + * MessageHandlerFunc is a function type for handling incoming datastream messages + * Expects parsed DataStreamResp messages + */ +export type MessageHandlerFunc = (ctx: any, message: DataStreamResp) => Promise; + +/** + * ConnectionReadyHandlerFunc is a function type for functions that need to be called before connection is considered ready + */ +export type ConnectionReadyHandlerFunc = (ctx: any) => Promise; + +/** + * ClientOptions contains configuration for the datastream client + */ +export interface ClientOptions { + /** HTTP API URL or WebSocket URL - HTTP URLs will be automatically converted to WebSocket URLs */ + url: string; + /** Schematic API key for authentication */ + apiKey: string; + /** Handler for incoming messages */ + messageHandler: MessageHandlerFunc; + /** Handler called when connection is ready */ + connectionReadyHandler?: ConnectionReadyHandlerFunc; + /** Logger for debug/info/error messages */ + logger: Logger; + /** Maximum number of reconnection attempts */ + maxReconnectAttempts?: number; + /** Minimum delay between reconnection attempts */ + minReconnectDelay?: number; + /** Maximum delay between reconnection attempts */ + maxReconnectDelay?: number; +} + +/** + * convertAPIURLToWebSocketURL converts an API URL to a WebSocket datastream URL + * Examples: + * https://api.schematichq.com -> wss://datastream.schematichq.com/datastream + * https://api.staging.example.com -> wss://datastream.staging.example.com/datastream + * https://custom.example.com -> wss://custom.example.com/datastream + * http://localhost:8080 -> ws://localhost:8080/datastream + */ +function convertAPIURLToWebSocketURL(apiURL: string): any { + const URLClass = createURL(); + const parsedURL = new URLClass(apiURL); + + // Convert HTTP schemes to WebSocket schemes + switch (parsedURL.protocol) { + case 'https:': + parsedURL.protocol = 'wss:'; + break; + case 'http:': + parsedURL.protocol = 'ws:'; + break; + default: + throw new Error(`Unsupported scheme: ${parsedURL.protocol} (must be http: or https:)`); + } + + // Replace 'api' subdomain with 'datastream' if present + if (parsedURL.hostname) { + const hostParts = parsedURL.hostname.split('.'); + if (hostParts.length > 1 && hostParts[0] === 'api') { + hostParts[0] = 'datastream'; + parsedURL.hostname = hostParts.join('.'); + } + } + + // Add datastream path + parsedURL.pathname = '/datastream'; + + return parsedURL; +} + +/** + * DatastreamWSClient represents a Schematic datastream websocket client with automatic reconnection + */ +export class DatastreamWSClient extends EventEmitter { + // Configuration + private readonly url: any; + private readonly headers: Record; + private readonly logger: Logger; + private readonly messageHandler: MessageHandlerFunc; + private readonly connectionReadyHandler?: ConnectionReadyHandlerFunc; + private readonly maxReconnectAttempts: number; + private readonly minReconnectDelay: number; + private readonly maxReconnectDelay: number; + + // Connection state + private ws?: any; + private connected: boolean = false; + private ready: boolean = false; + + // Control state + private shouldReconnect: boolean = true; + private reconnectAttempts: number = 0; + private pingInterval?: NodeJS.Timeout; + private pongTimeout?: NodeJS.Timeout; + private reconnectTimeout?: NodeJS.Timeout; + + // Context + private ctx: any = {}; + + constructor(options: ClientOptions) { + super(); + + if (!options.url) { + throw new Error('URL is required'); + } + + if (!options.apiKey) { + throw new Error('ApiKey is required'); + } + + if (!options.messageHandler) { + throw new Error('MessageHandler is required'); + } + + // Auto-detect if this is an HTTP/HTTPS URL that needs conversion to WebSocket + if (options.url.startsWith('http://') || options.url.startsWith('https://')) { + this.url = convertAPIURLToWebSocketURL(options.url); + } else { + const URLClass = createURL(); + this.url = new URLClass(options.url); + } + + // Create headers with API key + this.headers = { + 'X-Schematic-Api-Key': options.apiKey, + }; + + this.logger = options.logger; + this.messageHandler = options.messageHandler; + this.connectionReadyHandler = options.connectionReadyHandler; + + // Set defaults + this.maxReconnectAttempts = options.maxReconnectAttempts ?? MAX_RECONNECT_ATTEMPTS; + this.minReconnectDelay = options.minReconnectDelay ?? MIN_RECONNECT_DELAY; + this.maxReconnectDelay = options.maxReconnectDelay ?? MAX_RECONNECT_DELAY; + } + + /** + * Start begins the WebSocket connection and message handling + */ + public start(): void { + this.shouldReconnect = true; + this.reconnectAttempts = 0; + this.connectAndRead(); + } + + /** + * IsConnected returns whether the WebSocket is currently connected + */ + public isConnected(): boolean { + return this.connected; + } + + /** + * IsReady returns whether the datastream client is ready (connected + initialized) + */ + public isReady(): boolean { + return this.ready && this.connected; + } + + /** + * SendMessage sends a message through the WebSocket connection + */ + public async sendMessage(message: any): Promise { + if (!this.isConnected() || !this.ws) { + throw new Error('WebSocket connection is not available!'); + } + + return new Promise((resolve, reject) => { + if (!this.ws) { + reject(new Error('WebSocket connection is not available!')); + return; + } + + const timeout = setTimeout(() => { + reject(new Error('Write timeout')); + }, WRITE_WAIT); + + try { + this.ws.send(JSON.stringify(message), (err: Error | undefined) => { + clearTimeout(timeout); + if (err) { + reject(err); + } else { + resolve(); + } + }); + } catch (err) { + clearTimeout(timeout); + reject(err); + } + }); + } + + /** + * Close gracefully closes the WebSocket connection + */ + public close(): void { + this.logger.info('Closing WebSocket connection'); + + this.shouldReconnect = false; + this.setReady(false); + this.setConnected(false); + + // Clear all timeouts + if (this.pingInterval) { + clearInterval(this.pingInterval); + this.pingInterval = undefined; + } + if (this.pongTimeout) { + clearTimeout(this.pongTimeout); + this.pongTimeout = undefined; + } + if (this.reconnectTimeout) { + clearTimeout(this.reconnectTimeout); + this.reconnectTimeout = undefined; + } + + // Close WebSocket connection + if (this.ws) { + this.ws.close(); + this.ws = undefined; + } + + } + + /** + * connectAndRead handles the main connection lifecycle + */ + private async connectAndRead(): Promise { + try { + while (this.shouldReconnect) { + try { + const ws = await this.connect(); + + this.reconnectAttempts = 0; + this.ws = ws; + this.setConnected(true); + + // Set up message handlers + this.setupWebSocketHandlers(ws); + + // Call connection ready handler if provided + if (this.connectionReadyHandler) { + try { + await this.connectionReadyHandler(this.ctx); + this.logger.debug('Connection ready handler completed successfully'); + } catch (err) { + this.logger.error(`Connection ready handler failed: ${err}`); + this.setConnected(false); + this.setReady(false); + ws.close(); + continue; + } + } + + // Mark as ready only after successful initialization + this.setReady(true); + this.logger.debug('WebSocket client is ready'); + + // Start ping/pong mechanism + this.startPingPong(); + + // Wait for connection to close or error + await new Promise((resolve) => { + const onClose = () => { + this.logger.info('WebSocket connection closed'); + this.cleanup(); + resolve(); + }; + + const onError = (error: Error) => { + this.logger.error(`WebSocket error: ${error.message}`); + this.emit('error', error); + this.cleanup(); + resolve(); + }; + + ws.on('close', onClose); + ws.on('error', onError); + }); + + if (!this.shouldReconnect) { + break; + } + + + } catch (err) { + this.reconnectAttempts++; + this.setConnected(false); + this.setReady(false); + + const error = err instanceof Error ? err.message : String(err); + this.logger.warn(`WebSocket connection failed: ${error}, attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts}`); + + if (this.reconnectAttempts >= this.maxReconnectAttempts) { + this.logger.error('Max reconnection attempts reached'); + this.emit('error', new Error('Max reconnection attempts reached')); + break; + } + + const delay = this.calculateBackoffDelay(this.reconnectAttempts); + this.logger.debug(`Waiting ${delay}ms before reconnecting...`); + + await new Promise(resolve => { + this.reconnectTimeout = setTimeout(resolve, delay); + }); + } + } + } catch (err) { + this.emit('error', err); + } + } + + /** + * connect establishes the WebSocket connection + */ + private connect(): Promise { + return new Promise((resolve, reject) => { + this.logger.debug(`Connecting to WebSocket: ${this.url.toString()}`); + + const WebSocketClass = createWebSocket(); + const ws = new WebSocketClass(this.url.toString(), { + headers: this.headers, + handshakeTimeout: 30000, // 30 seconds + }); + + const timeout = setTimeout(() => { + ws.close(); + reject(new Error('Connection timeout')); + }, 30000); + + ws.on('open', () => { + clearTimeout(timeout); + resolve(ws); + }); + + ws.on('error', (error: Error) => { + clearTimeout(timeout); + reject(error); + }); + }); + } + + /** + * setupWebSocketHandlers sets up message and error handlers for the WebSocket + */ + private setupWebSocketHandlers(ws: any): void { + ws.on('message', (data: any) => { + this.handleMessage(data); + }); + + ws.on('pong', () => { + this.handlePong(); + }); + + ws.on('close', (code: number, reason: Buffer) => { + this.handleClose(code); + }); + + ws.on('error', (error: Error) => { + this.handleError(error); + }); + } + + /** + * handleMessage processes incoming WebSocket messages + */ + private async handleMessage(data: any): Promise { + try { + + let messageStr: string; + if (Buffer.isBuffer(data)) { + messageStr = data.toString(); + } else if (Array.isArray(data)) { + messageStr = Buffer.concat(data).toString(); + } else { + messageStr = data.toString(); + } + + // Parse the datastream message + let message: DataStreamResp; + try { + message = JSON.parse(messageStr); + } catch (err) { + this.emit('error', new Error(`Failed to parse datastream message: ${err}`)); + return; + } + + + // Handle the parsed message using the provided handler + try { + await this.messageHandler(this.ctx, message); + } catch (err) { + this.emit('error', new Error(`Message handler error: ${err}`)); + } + } catch (err) { + this.emit('error', err); + } + } + + /** + * handleClose processes WebSocket close events + */ + private handleClose(code: number): void { + this.logger.info(`WebSocket connection closed with code ${code}`); + this.setConnected(false); + this.setReady(false); + this.cleanup(); + } + + /** + * handleError processes WebSocket error events + */ + private handleError(error: Error): void { + this.logger.error(`WebSocket error: ${error.message}`); + this.setConnected(false); + this.setReady(false); + this.cleanup(); + } + + /** + * startPingPong initiates the ping/pong keepalive mechanism + */ + private startPingPong(): void { + this.logger.debug('Starting ping/pong keepalive mechanism'); + this.pingInterval = setInterval(() => { + this.sendPing(); + }, PING_PERIOD); + } + + /** + * sendPing sends a ping message to keep the connection alive + */ + private sendPing(): void { + if (!this.ws) { + return; + } + + + // Set pong timeout + this.pongTimeout = setTimeout(() => { + this.logger.warn('Pong timeout - closing connection'); + this.setConnected(false); + if (this.ws) { + this.ws.close(); + } + }, PONG_WAIT); + + try { + this.ws.ping(); + } catch (err) { + this.logger.error(`Failed to send ping: ${err}`); + this.setConnected(false); + } + } + + /** + * handlePong handles pong responses from the server + */ + private handlePong(): void { + this.logger.debug('Received pong from server'); + if (this.pongTimeout) { + clearTimeout(this.pongTimeout); + this.pongTimeout = undefined; + } + } + + /** + * calculateBackoffDelay calculates exponential backoff delay with jitter + */ + private calculateBackoffDelay(attempt: number): number { + // Add jitter to prevent synchronized reconnection attempts + const jitter = Math.floor(Math.random() * this.minReconnectDelay); + + // Exponential backoff with a cap + const delay = Math.pow(2, attempt - 1) * this.minReconnectDelay + jitter; + return Math.min(delay, this.maxReconnectDelay + jitter); + } + + /** + * setConnected updates the connection state + */ + private setConnected(connected: boolean): void { + const wasConnected = this.connected; + this.connected = connected; + + // If disconnected, also set ready to false + if (!connected) { + this.ready = false; + } + + // Emit connection state change events + if (wasConnected !== connected) { + this.logger.debug(`Connection state changed: ${connected}`); + if (connected) { + this.emit('connected'); + } else { + this.emit('disconnected'); + } + } + } + + /** + * setReady updates the ready state + */ + private setReady(ready: boolean): void { + const wasReady = this.ready; + this.ready = ready; + + // Emit ready state change events + if (wasReady !== ready) { + this.logger.debug(`Ready state changed: ${ready}`); + if (ready) { + this.emit('ready'); + } else { + this.emit('not-ready'); + } + } + } + + /** + * cleanup clears timeouts and intervals + */ + private cleanup(): void { + if (this.pingInterval) { + clearInterval(this.pingInterval); + this.pingInterval = undefined; + } + if (this.pongTimeout) { + clearTimeout(this.pongTimeout); + this.pongTimeout = undefined; + } + } +} \ No newline at end of file diff --git a/src/index.ts b/src/index.ts index e35cf866..099ecc3b 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,8 +1,12 @@ export * as Schematic from "./api"; -export { LocalCache } from "./cache"; +export { LocalCache } from "./cache/local"; +export { RedisCacheProvider } from "./cache/redis"; export { SchematicClient } from "./wrapper"; +export type { RedisOptions } from "./cache/redis"; +export type { DataStreamRedisConfig } from "./datastream"; export { SchematicEnvironment } from "./environments"; export { SchematicError, SchematicTimeoutError } from "./errors"; +export { RulesEngineClient } from "./rules-engine"; export { verifyWebhookSignature, verifySignature, diff --git a/src/rules-engine.test.ts b/src/rules-engine.test.ts new file mode 100644 index 00000000..2a8eaeb4 --- /dev/null +++ b/src/rules-engine.test.ts @@ -0,0 +1,302 @@ +import { RulesEngineClient } from './rules-engine'; + +// Mock data using realistic test data structures +const mockFlag = { + id: 'test-flag', + account_id: 'account-123', + environment_id: 'env-123', + key: 'test-feature', + default_value: false, + rules: [ + { + id: 'rule-1', + account_id: 'account-123', + environment_id: 'env-123', + name: 'Basic Access Rule', + rule_type: 'plan_entitlement', + priority: 100, + value: true, + conditions: [ + { + id: 'condition-1', + account_id: 'account-123', + environment_id: 'env-123', + condition_type: 'trait', + operator: 'lte', + resource_ids: [], + trait_value: '10' + } + ] + } + ] +}; + +const mockCompany = { + id: 'company-123', + account_id: 'account-123', + environment_id: 'env-123', + base_plan_id: 'plan-pro', + billing_product_ids: [], + crm_product_ids: [], + keys: { + id: 'company-123', + slug: 'test-company' + }, + plan_ids: ['plan-pro'], + metrics: [], + credit_balances: {}, + subscription: { + id: 'sub-123', + period_start: '2023-01-01T00:00:00Z', + period_end: '2023-02-01T00:00:00Z' + }, + traits: [], + rules: [] +}; + +const mockUser = { + id: 'user-456', + account_id: 'account-123', + environment_id: 'env-123', + keys: { + id: 'user-456', + email: 'test@example.com' + }, + traits: [], + rules: [] +}; + +const mockRule = { + id: 'test-rule', + account_id: 'account-123', + environment_id: 'env-123', + name: 'Test Rule', + rule_type: 'plan_entitlement', + priority: 100, + value: true, + conditions: [ + { + id: 'condition-2', + account_id: 'account-123', + environment_id: 'env-123', + condition_type: 'trait', + operator: 'eq', + trait_value: 'pro' + } + ] +}; + +describe('RulesEngineClient', () => { + let rulesEngine: RulesEngineClient; + + beforeEach(async () => { + rulesEngine = new RulesEngineClient(); + await rulesEngine.initialize(); + }); + + describe('Initialization', () => { + test('should initialize successfully', async () => { + const engine = new RulesEngineClient(); + await engine.initialize(); + expect(engine.isInitialized()).toBe(true); + }); + + test('should not reinitialize if already initialized', async () => { + expect(rulesEngine.isInitialized()).toBe(true); + // Should not throw + await rulesEngine.initialize(); + expect(rulesEngine.isInitialized()).toBe(true); + }); + + test('should throw error when using methods before initialization', async () => { + const engine = new RulesEngineClient(); + expect(() => engine.getVersionKey()).toThrow('WASM rules engine not initialized'); + }); + }); + + describe('Version Information', () => { + test('should return version key', () => { + const version = rulesEngine.getVersionKey(); + expect(version).toBeDefined(); + expect(typeof version).toBe('string'); + expect(version.length).toBeGreaterThan(0); + }); + }); + + describe('Flag Checking', () => { + test('should check flag with company and user context', async () => { + const result = await rulesEngine.checkFlag(mockFlag, mockCompany, mockUser); + + expect(result).toBeDefined(); + expect(typeof result).toBe('object'); + expect(result).toHaveProperty('value'); + expect(result).toHaveProperty('reason'); + expect(result).toHaveProperty('rule_id'); + }); + + test('should check flag with only company context', async () => { + const result = await rulesEngine.checkFlag(mockFlag, mockCompany); + + expect(result).toBeDefined(); + expect(typeof result).toBe('object'); + }); + + test('should check flag with only user context', async () => { + const result = await rulesEngine.checkFlag(mockFlag, undefined, mockUser); + + expect(result).toBeDefined(); + expect(typeof result).toBe('object'); + }); + + test('should check flag without context', async () => { + const result = await rulesEngine.checkFlag(mockFlag); + + expect(result).toBeDefined(); + expect(typeof result).toBe('object'); + }); + + test('should handle invalid flag JSON', async () => { + const invalidFlag = { id: 'test', invalid_field: undefined }; + + // Should reject invalid data structures that don't match the expected schema + await expect(rulesEngine.checkFlag(invalidFlag)).rejects.toThrow(); + }); + + test('should return consistent results for identical inputs', async () => { + const result1 = await rulesEngine.checkFlag(mockFlag, mockCompany, mockUser); + const result2 = await rulesEngine.checkFlag(mockFlag, mockCompany, mockUser); + + expect(result1).toEqual(result2); + }); + }); + + describe('Rule Evaluation', () => { + test('should evaluate rule with company and user context', async () => { + const result = await rulesEngine.evaluateRule(mockRule, mockCompany, mockUser); + + expect(typeof result).toBe('boolean'); + }); + + test('should evaluate rule with only company context', async () => { + const result = await rulesEngine.evaluateRule(mockRule, mockCompany); + + expect(typeof result).toBe('boolean'); + }); + + test('should evaluate rule without context', async () => { + const result = await rulesEngine.evaluateRule(mockRule); + + expect(typeof result).toBe('boolean'); + }); + + test('should handle complex rule conditions', async () => { + const complexRule = { + ...mockRule, + conditions: [ + { + id: 'condition-3', + account_id: 'account-123', + environment_id: 'env-123', + condition_type: 'trait', + operator: 'eq', + trait_value: 'pro' + }, + { + id: 'condition-4', + account_id: 'account-123', + environment_id: 'env-123', + condition_type: 'trait', + operator: 'gte', + trait_value: '1' + } + ] + }; + + const result = await rulesEngine.evaluateRule(complexRule, mockCompany, mockUser); + expect(typeof result).toBe('boolean'); + }); + + test('should return consistent results for identical rule inputs', async () => { + const result1 = await rulesEngine.evaluateRule(mockRule, mockCompany, mockUser); + const result2 = await rulesEngine.evaluateRule(mockRule, mockCompany, mockUser); + + expect(result1).toBe(result2); + }); + }); + + describe('Error Handling', () => { + test('should handle malformed JSON gracefully', async () => { + // Test with circular reference (should be handled by JSON.stringify error) + const circularFlag = { ...mockFlag }; + (circularFlag as any).self = circularFlag; + + await expect(rulesEngine.checkFlag(circularFlag)).rejects.toThrow(); + }); + + test('should provide meaningful error messages', async () => { + try { + await rulesEngine.checkFlag(null as any); + } catch (error) { + expect(error).toBeInstanceOf(Error); + expect((error as Error).message).toContain('WASM flag check failed'); + } + }); + }); + + describe('Performance', () => { + test('should handle multiple concurrent operations', async () => { + const promises = Array.from({ length: 10 }, (_, i) => + rulesEngine.checkFlag({ ...mockFlag, id: `flag-${i}` }, mockCompany, mockUser) + ); + + const results = await Promise.all(promises); + expect(results).toHaveLength(10); + results.forEach(result => { + expect(result).toBeDefined(); + expect(typeof result).toBe('object'); + }); + }); + + test('should complete operations within reasonable time', async () => { + const start = Date.now(); + + await rulesEngine.checkFlag(mockFlag, mockCompany, mockUser); + + const duration = Date.now() - start; + expect(duration).toBeLessThan(100); // Should complete within 100ms + }); + }); + + describe('Memory Management', () => { + test('should handle large datasets without memory leaks', async () => { + const largeCompany = { + ...mockCompany, + traits: [ + // Add many traits to test memory handling + ...Array.from({ length: 1000 }, (_, i) => ({ + value: `value_${i}`, + trait_definition: { + id: `trait_${i}`, + comparable_type: 'string', + entity_type: 'company' + } + })) + ] + }; + + // Should complete without throwing memory errors + const result = await rulesEngine.checkFlag(mockFlag, largeCompany, mockUser); + expect(result).toBeDefined(); + }); + }); +}); + +describe('Module Exports', () => { + test('should export RulesEngineClient as named export', () => { + expect(RulesEngineClient).toBeDefined(); + expect(typeof RulesEngineClient).toBe('function'); + }); test('should export default export', async () => { + const { default: DefaultExport } = await import('./rules-engine'); + expect(DefaultExport).toBe(RulesEngineClient); + }); +}); \ No newline at end of file diff --git a/src/rules-engine.ts b/src/rules-engine.ts new file mode 100644 index 00000000..fa9fe5dd --- /dev/null +++ b/src/rules-engine.ts @@ -0,0 +1,120 @@ +import { RulesEngineJS } from './wasm/rulesengine.js'; + +/** + * High-performance rules engine for flag evaluation and rule processing. + * + * This engine provides significant performance improvements over traditional JavaScript + * implementations by leveraging compiled Rust code running in WebAssembly. + */ +export class RulesEngineClient { + private wasmInstance: RulesEngineJS | null = null; + private initialized = false; + + constructor() {} + + /** + * Initialize the WASM rules engine. + * Must be called before using any other methods. + */ + async initialize(): Promise { + if (this.initialized) { + return; + } + + try { + // Initialize the WASM module + this.wasmInstance = new RulesEngineJS(); + this.initialized = true; + } catch (error) { + throw new Error(`Failed to initialize WASM rules engine: ${error}`); + } + } + + /** + * Check a feature flag using the WASM engine. + * + * @param flag - The flag configuration object + * @param company - Optional company context + * @param user - Optional user context + * @returns Promise resolving to the flag check result + */ + async checkFlag( + flag: any, + company?: any, + user?: any + ): Promise { + this.ensureInitialized(); + + try { + const flagJson = JSON.stringify(flag); + const companyJson = company ? JSON.stringify(company) : undefined; + const userJson = user ? JSON.stringify(user) : undefined; + + const resultJson = this.wasmInstance!.checkFlag( + flagJson, + companyJson, + userJson + ); + + // Parse the JSON string returned by WASM + return JSON.parse(resultJson); + } catch (error) { + throw new Error(`WASM flag check failed: ${error}`); + } + } + + /** + * Evaluate a rule using the WASM engine. + * + * @param rule - The rule configuration object + * @param company - Optional company context + * @param user - Optional user context + * @returns Promise resolving to boolean indicating if rule matched + */ + async evaluateRule( + rule: any, + company?: any, + user?: any + ): Promise { + this.ensureInitialized(); + + try { + const ruleJson = JSON.stringify(rule); + const companyJson = company ? JSON.stringify(company) : undefined; + const userJson = user ? JSON.stringify(user) : undefined; + + return this.wasmInstance!.evaluateRule( + ruleJson, + companyJson, + userJson + ); + } catch (error) { + throw new Error(`WASM rule evaluation failed: ${error}`); + } + } + + /** + * Get the version key of the WASM rules engine. + * Useful for debugging and compatibility checking. + */ + getVersionKey(): string { + this.ensureInitialized(); + return this.wasmInstance!.getVersionKey(); + } + + /** + * Check if the engine is initialized. + */ + isInitialized(): boolean { + return this.initialized; + } + + private ensureInitialized(): void { + if (!this.initialized || !this.wasmInstance) { + throw new Error('WASM rules engine not initialized. Call initialize() first.'); + } + } +} + +// Export for backward compatibility +export { RulesEngineClient as default }; \ No newline at end of file diff --git a/src/wasm/rulesengine.d.ts b/src/wasm/rulesengine.d.ts new file mode 100644 index 00000000..4ab1f4d8 --- /dev/null +++ b/src/wasm/rulesengine.d.ts @@ -0,0 +1,10 @@ +/* tslint:disable */ +/* eslint-disable */ +export class RulesEngineJS { + free(): void; + [Symbol.dispose](): void; + checkFlag(flag_json: string, company_json?: string | null, user_json?: string | null): string; + evaluateRule(rule_json: string, company_json?: string | null, user_json?: string | null): boolean; + getVersionKey(): string; + constructor(); +} diff --git a/src/wasm/rulesengine.js b/src/wasm/rulesengine.js new file mode 100644 index 00000000..ee2f4f99 --- /dev/null +++ b/src/wasm/rulesengine.js @@ -0,0 +1,210 @@ + +let imports = {}; +imports['__wbindgen_placeholder__'] = module.exports; + +let cachedUint8ArrayMemory0 = null; + +function getUint8ArrayMemory0() { + if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { + cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8ArrayMemory0; +} + +let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + +cachedTextDecoder.decode(); + +function decodeText(ptr, len) { + return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); +} + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return decodeText(ptr, len); +} + +let WASM_VECTOR_LEN = 0; + +const cachedTextEncoder = new TextEncoder(); + +if (!('encodeInto' in cachedTextEncoder)) { + cachedTextEncoder.encodeInto = function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; + } +} + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + + const mem = getUint8ArrayMemory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); + const ret = cachedTextEncoder.encodeInto(arg, view); + + offset += ret.written; + ptr = realloc(ptr, len, offset, 1) >>> 0; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +function isLikeNone(x) { + return x === undefined || x === null; +} + +function takeFromExternrefTable0(idx) { + const value = wasm.__wbindgen_externrefs.get(idx); + wasm.__externref_table_dealloc(idx); + return value; +} + +const RulesEngineJSFinalization = (typeof FinalizationRegistry === 'undefined') + ? { register: () => {}, unregister: () => {} } + : new FinalizationRegistry(ptr => wasm.__wbg_rulesenginejs_free(ptr >>> 0, 1)); + +class RulesEngineJS { + + __destroy_into_raw() { + const ptr = this.__wbg_ptr; + this.__wbg_ptr = 0; + RulesEngineJSFinalization.unregister(this); + return ptr; + } + + free() { + const ptr = this.__destroy_into_raw(); + wasm.__wbg_rulesenginejs_free(ptr, 0); + } + /** + * @param {string} flag_json + * @param {string | null} [company_json] + * @param {string | null} [user_json] + * @returns {string} + */ + checkFlag(flag_json, company_json, user_json) { + let deferred5_0; + let deferred5_1; + try { + const ptr0 = passStringToWasm0(flag_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + var ptr1 = isLikeNone(company_json) ? 0 : passStringToWasm0(company_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + var len1 = WASM_VECTOR_LEN; + var ptr2 = isLikeNone(user_json) ? 0 : passStringToWasm0(user_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + var len2 = WASM_VECTOR_LEN; + const ret = wasm.rulesenginejs_checkFlag(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2); + var ptr4 = ret[0]; + var len4 = ret[1]; + if (ret[3]) { + ptr4 = 0; len4 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred5_0 = ptr4; + deferred5_1 = len4; + return getStringFromWasm0(ptr4, len4); + } finally { + wasm.__wbindgen_free(deferred5_0, deferred5_1, 1); + } + } + /** + * @param {string} rule_json + * @param {string | null} [company_json] + * @param {string | null} [user_json] + * @returns {boolean} + */ + evaluateRule(rule_json, company_json, user_json) { + const ptr0 = passStringToWasm0(rule_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + var ptr1 = isLikeNone(company_json) ? 0 : passStringToWasm0(company_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + var len1 = WASM_VECTOR_LEN; + var ptr2 = isLikeNone(user_json) ? 0 : passStringToWasm0(user_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + var len2 = WASM_VECTOR_LEN; + const ret = wasm.rulesenginejs_evaluateRule(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return ret[0] !== 0; + } + /** + * @returns {string} + */ + getVersionKey() { + let deferred1_0; + let deferred1_1; + try { + const ret = wasm.rulesenginejs_getVersionKey(this.__wbg_ptr); + deferred1_0 = ret[0]; + deferred1_1 = ret[1]; + return getStringFromWasm0(ret[0], ret[1]); + } finally { + wasm.__wbindgen_free(deferred1_0, deferred1_1, 1); + } + } + constructor() { + const ret = wasm.rulesenginejs_new(); + this.__wbg_ptr = ret >>> 0; + RulesEngineJSFinalization.register(this, this.__wbg_ptr, this); + return this; + } +} +if (Symbol.dispose) RulesEngineJS.prototype[Symbol.dispose] = RulesEngineJS.prototype.free; + +exports.RulesEngineJS = RulesEngineJS; + +exports.__wbg___wbindgen_throw_b855445ff6a94295 = function(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); +}; + +exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) { + // Cast intrinsic for `Ref(String) -> Externref`. + const ret = getStringFromWasm0(arg0, arg1); + return ret; +}; + +exports.__wbindgen_init_externref_table = function() { + const table = wasm.__wbindgen_externrefs; + const offset = table.grow(4); + table.set(0, undefined); + table.set(offset + 0, undefined); + table.set(offset + 1, null); + table.set(offset + 2, true); + table.set(offset + 3, false); + ; +}; + +const wasmPath = `${__dirname}/rulesengine_bg.wasm`; +const wasmBytes = require('fs').readFileSync(wasmPath); +const wasmModule = new WebAssembly.Module(wasmBytes); +const wasm = exports.__wasm = new WebAssembly.Instance(wasmModule, imports).exports; + +wasm.__wbindgen_start(); + diff --git a/src/wasm/rulesengine_bg.wasm b/src/wasm/rulesengine_bg.wasm new file mode 100644 index 00000000..b931b8d1 Binary files /dev/null and b/src/wasm/rulesengine_bg.wasm differ diff --git a/src/wasm/rulesengine_bg.wasm.d.ts b/src/wasm/rulesengine_bg.wasm.d.ts new file mode 100644 index 00000000..3bafd9e0 --- /dev/null +++ b/src/wasm/rulesengine_bg.wasm.d.ts @@ -0,0 +1,24 @@ +/* tslint:disable */ +/* eslint-disable */ +export const memory: WebAssembly.Memory; +export const __wbg_rulesenginejs_free: (a: number, b: number) => void; +export const checkFlag: (a: number, b: number, c: number, d: number, e: number, f: number) => number; +export const evaluateRule: (a: number, b: number, c: number, d: number, e: number, f: number) => number; +export const getCurrentMetricPeriodStartForCalendarMetricPeriod: (a: number) => bigint; +export const getCurrentMetricPeriodStartForCompanyBillingSubscription: (a: number, b: number) => bigint; +export const getNextMetricPeriodStartForCalendarMetricPeriod: (a: number) => bigint; +export const getNextMetricPeriodStartForCompanyBillingSubscription: (a: number, b: number) => bigint; +export const getResultJson: () => number; +export const getResultJsonLength: () => number; +export const get_version_key_wasm: () => number; +export const rulesenginejs_checkFlag: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number, number]; +export const rulesenginejs_evaluateRule: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number]; +export const rulesenginejs_getVersionKey: (a: number) => [number, number]; +export const rulesenginejs_new: () => number; +export const test_function: () => number; +export const __wbindgen_externrefs: WebAssembly.Table; +export const __wbindgen_malloc: (a: number, b: number) => number; +export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number; +export const __externref_table_dealloc: (a: number) => void; +export const __wbindgen_free: (a: number, b: number, c: number) => void; +export const __wbindgen_start: () => void; diff --git a/src/wrapper.ts b/src/wrapper.ts index e5fdbedb..ea66fd88 100644 --- a/src/wrapper.ts +++ b/src/wrapper.ts @@ -1,10 +1,11 @@ import * as api from "./api"; import { SchematicClient as BaseClient } from "./Client"; -import { CacheProvider, LocalCache } from "./cache"; +import { type CacheProvider, LocalCache } from "./cache"; import { ConsoleLogger, Logger } from "./logger"; import { EventBuffer } from "./events"; import { offlineFetcher, provideFetcher } from "./core/fetcher/custom"; +import { DataStreamClient, type DataStreamClientOptions, type DataStreamRedisConfig } from "./datastream"; /** * Configuration options for the SchematicClient @@ -19,6 +20,21 @@ export interface SchematicOptions { /** Providers for caching flag check results */ flagChecks?: CacheProvider[]; }; + /** Enable DataStream for real-time updates */ + useDataStream?: boolean; + /** DataStream configuration options */ + dataStream?: { + /** Cache TTL in milliseconds (default: 5 minutes) */ + cacheTTL?: number; + /** Redis configuration for DataStream caching */ + redisConfig?: DataStreamRedisConfig; + /** Enable replicator mode for external data synchronization */ + replicatorMode?: boolean; + /** Health check URL for replicator mode */ + replicatorHealthURL?: string; + /** Health check interval for replicator mode in milliseconds */ + replicatorHealthCheck?: number; + }; /** If using an API key that is not environment-specific, use this option to specify the environment */ environmentId?: string; /** Interval in milliseconds for flushing event buffer */ @@ -43,6 +59,7 @@ export interface CheckFlagOptions { } export class SchematicClient extends BaseClient { + private datastreamClient?: DataStreamClient; private eventBuffer: EventBuffer; private flagCheckCacheProviders: CacheProvider[]; private flagDefaults: { [key: string]: boolean }; @@ -100,6 +117,33 @@ export class SchematicClient extends BaseClient { this.flagCheckCacheProviders = opts?.cacheProviders?.flagChecks ?? [new LocalCache()]; this.flagDefaults = flagDefaults; this.offline = offline; + + // Initialize DataStream client if enabled + if (opts?.useDataStream && !offline) { + const datastreamOptions: DataStreamClientOptions = { + apiKey, + baseURL: basePath, + logger, + cacheTTL: opts.dataStream?.cacheTTL, + redisConfig: opts.dataStream?.redisConfig, + replicatorMode: opts.dataStream?.replicatorMode, + replicatorHealthURL: opts.dataStream?.replicatorHealthURL, + replicatorHealthCheck: opts.dataStream?.replicatorHealthCheck, + }; + + this.datastreamClient = new DataStreamClient(datastreamOptions); + this.datastreamClient.start().catch((error) => { + logger.error(`Failed to start DataStream client: ${error}`); + this.datastreamClient = undefined; + }); + } + } + + /** + * Returns whether DataStream is enabled and available + */ + private useDataStream(): boolean { + return this.datastreamClient !== undefined; } /** @@ -123,11 +167,48 @@ export class SchematicClient extends BaseClient { return getDefault(); } + if (this.useDataStream()) { + try { + const resp = await this.datastreamClient!.checkFlag(evalCtx, key); + + // Extract boolean value from DataStream response + const flagValue = typeof resp === 'boolean' ? resp : resp?.value; + + // Track the flag check event + this.track({ + event: "flag_check", + company: evalCtx.company, + user: evalCtx.user, + traits: { + flag_key: key, + value: flagValue, + company_id: resp?.companyId, + user_id: resp?.userId, + flag_id: resp?.flagId, + req_company: evalCtx.company, + req_user: evalCtx.user, + reason: resp?.reason, + }, + }); + + return flagValue ?? this.getFlagDefault(key); + } catch (err) { + this.logger.debug(`Datastream flag check failed (${err}), falling back to API`); + return this.checkFlagViaAPI(evalCtx, key, options, getDefault); + } + } + + return this.checkFlagViaAPI(evalCtx, key, options, getDefault); + } + + private async checkFlagViaAPI(evalCtx: api.CheckFlagRequestBody, key: string, options?: CheckFlagOptions, getDefault?: () => boolean): Promise { + const getDefaultValue = getDefault ?? (() => this.getFlagDefault(key)); + try { const cacheKey = JSON.stringify({ evalCtx, key }); for (const provider of this.flagCheckCacheProviders) { const cachedValue = await provider.get(cacheKey); - if (cachedValue !== undefined) { + if (cachedValue !== null && cachedValue !== undefined) { this.logger.debug(`${provider.constructor.name} cache hit for flag ${key}`); return cachedValue; } @@ -138,7 +219,7 @@ export class SchematicClient extends BaseClient { }); if (response.data.value === undefined) { this.logger.debug(`No value returned from feature flag API for flag ${key}, falling back to default`); - return getDefault(); + return getDefaultValue(); } for (const provider of this.flagCheckCacheProviders) { @@ -150,7 +231,7 @@ export class SchematicClient extends BaseClient { return response.data.value; } catch (err) { this.logger.error(`Error checking flag ${key}: ${err}`); - return getDefault(); + return getDefaultValue(); } } @@ -194,7 +275,7 @@ export class SchematicClient extends BaseClient { for (const provider of this.flagCheckCacheProviders) { const cachedValue = await provider.get(cacheKey); - if (cachedValue !== undefined) { + if (cachedValue !== null && cachedValue !== undefined) { this.logger.debug(`${provider.constructor.name} cache hit for flag ${key}`); cachedResults.set(key, { flag: key, @@ -275,10 +356,13 @@ export class SchematicClient extends BaseClient { } /** - * Gracefully shuts down the client by stopping the event buffer - * @returns Promise that resolves when the event buffer has been stopped + * Gracefully shuts down the client by stopping the event buffer and DataStream client + * @returns Promise that resolves when everything has been stopped */ async close(): Promise { + if (this.datastreamClient) { + this.datastreamClient.close(); + } return this.eventBuffer.stop(); } @@ -309,6 +393,19 @@ export class SchematicClient extends BaseClient { try { await this.enqueueEvent("track", body); + + // Update company metrics in DataStream if available and connected + if (body.company && this.useDataStream() && this.datastreamClient!.isConnected()) { + try { + await this.datastreamClient!.updateCompanyMetrics( + body.company, + body.event, + body.quantity || 1 + ); + } catch (err) { + this.logger.error(`Failed to update company metrics: ${err}`); + } + } } catch (err) { this.logger.error(`Error sending track event: ${err}`); } diff --git a/yarn.lock b/yarn.lock index 8dd5331d..e5c76428 100644 --- a/yarn.lock +++ b/yarn.lock @@ -4,7 +4,7 @@ "@babel/code-frame@^7.0.0", "@babel/code-frame@^7.12.13", "@babel/code-frame@^7.27.1": version "7.27.1" - resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.27.1.tgz#200f715e66d52a23b221a9435534a91cc13ad5be" + resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz" integrity sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg== dependencies: "@babel/helper-validator-identifier" "^7.27.1" @@ -50,7 +50,7 @@ "@babel/helper-compilation-targets@^7.27.2": version "7.27.2" - resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz#46a0f6efab808d51d29ce96858dd10ce8732733d" + resolved "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz" integrity sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ== dependencies: "@babel/compat-data" "^7.27.2" @@ -61,12 +61,12 @@ "@babel/helper-globals@^7.28.0": version "7.28.0" - resolved "https://registry.yarnpkg.com/@babel/helper-globals/-/helper-globals-7.28.0.tgz#b9430df2aa4e17bc28665eadeae8aa1d985e6674" + resolved "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz" integrity sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw== "@babel/helper-module-imports@^7.27.1": version "7.27.1" - resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz#7ef769a323e2655e126673bb6d2d6913bbead204" + resolved "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz" integrity sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w== dependencies: "@babel/traverse" "^7.27.1" @@ -83,22 +83,27 @@ "@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.27.1", "@babel/helper-plugin-utils@^7.8.0": version "7.27.1" - resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz#ddb2f876534ff8013e6c2b299bf4d39b3c51d44c" + resolved "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz" integrity sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw== "@babel/helper-string-parser@^7.27.1": version "7.27.1" - resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz#54da796097ab19ce67ed9f88b47bb2ec49367687" + resolved "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz" integrity sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA== -"@babel/helper-validator-identifier@^7.27.1", "@babel/helper-validator-identifier@^7.28.5": +"@babel/helper-validator-identifier@^7.27.1": + version "7.27.1" + resolved "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz" + integrity sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow== + +"@babel/helper-validator-identifier@^7.28.5": version "7.28.5" resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz#010b6938fab7cb7df74aa2bbc06aa503b8fe5fb4" integrity sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q== "@babel/helper-validator-option@^7.27.1": version "7.27.1" - resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz#fa52f5b1e7db1ab049445b421c4471303897702f" + resolved "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz" integrity sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg== "@babel/helpers@^7.28.4": @@ -118,126 +123,126 @@ "@babel/plugin-syntax-async-generators@^7.8.4": version "7.8.4" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz" integrity sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-bigint@^7.8.3": version "7.8.3" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz#4c9a6f669f5d0cdf1b90a1671e9a146be5300cea" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz" integrity sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-class-properties@^7.12.13": version "7.12.13" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz" integrity sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA== dependencies: "@babel/helper-plugin-utils" "^7.12.13" "@babel/plugin-syntax-class-static-block@^7.14.5": version "7.14.5" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz#195df89b146b4b78b3bf897fd7a257c84659d406" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz" integrity sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw== dependencies: "@babel/helper-plugin-utils" "^7.14.5" "@babel/plugin-syntax-import-attributes@^7.24.7": version "7.27.1" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.27.1.tgz#34c017d54496f9b11b61474e7ea3dfd5563ffe07" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.27.1.tgz" integrity sha512-oFT0FrKHgF53f4vOsZGi2Hh3I35PfSmVs4IBFLFj4dnafP+hIWDLg3VyKmUHfLoLHlyxY4C7DGtmHuJgn+IGww== dependencies: "@babel/helper-plugin-utils" "^7.27.1" "@babel/plugin-syntax-import-meta@^7.10.4": version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz#ee601348c370fa334d2207be158777496521fd51" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz" integrity sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g== dependencies: "@babel/helper-plugin-utils" "^7.10.4" "@babel/plugin-syntax-json-strings@^7.8.3": version "7.8.3" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz" integrity sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-jsx@^7.7.2": version "7.27.1" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.27.1.tgz#2f9beb5eff30fa507c5532d107daac7b888fa34c" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.27.1.tgz" integrity sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w== dependencies: "@babel/helper-plugin-utils" "^7.27.1" "@babel/plugin-syntax-logical-assignment-operators@^7.10.4": version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz#ca91ef46303530448b906652bac2e9fe9941f699" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz" integrity sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig== dependencies: "@babel/helper-plugin-utils" "^7.10.4" "@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3": version "7.8.3" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz" integrity sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-numeric-separator@^7.10.4": version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz#b9b070b3e33570cd9fd07ba7fa91c0dd37b9af97" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz" integrity sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug== dependencies: "@babel/helper-plugin-utils" "^7.10.4" "@babel/plugin-syntax-object-rest-spread@^7.8.3": version "7.8.3" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz" integrity sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-optional-catch-binding@^7.8.3": version "7.8.3" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz#6111a265bcfb020eb9efd0fdfd7d26402b9ed6c1" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz" integrity sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-optional-chaining@^7.8.3": version "7.8.3" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz" integrity sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg== dependencies: "@babel/helper-plugin-utils" "^7.8.0" "@babel/plugin-syntax-private-property-in-object@^7.14.5": version "7.14.5" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz#0dc6671ec0ea22b6e94a1114f857970cd39de1ad" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz" integrity sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg== dependencies: "@babel/helper-plugin-utils" "^7.14.5" "@babel/plugin-syntax-top-level-await@^7.14.5": version "7.14.5" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz#c1cfdadc35a646240001f06138247b741c34d94c" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz" integrity sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw== dependencies: "@babel/helper-plugin-utils" "^7.14.5" "@babel/plugin-syntax-typescript@^7.7.2": version "7.27.1" - resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.27.1.tgz#5147d29066a793450f220c63fa3a9431b7e6dd18" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.27.1.tgz" integrity sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ== dependencies: "@babel/helper-plugin-utils" "^7.27.1" "@babel/template@^7.27.2", "@babel/template@^7.3.3": version "7.27.2" - resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.27.2.tgz#fa78ceed3c4e7b63ebf6cb39e5852fca45f6809d" + resolved "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz" integrity sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw== dependencies: "@babel/code-frame" "^7.27.1" @@ -267,7 +272,7 @@ "@bcoe/v8-coverage@^0.2.3": version "0.2.3" - resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39" + resolved "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz" integrity sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw== "@biomejs/biome@2.3.1": @@ -507,7 +512,7 @@ "@istanbuljs/load-nyc-config@^1.0.0": version "1.1.0" - resolved "https://registry.yarnpkg.com/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz#fd3db1d59ecf7cf121e80650bb86712f9b55eced" + resolved "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz" integrity sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ== dependencies: camelcase "^5.3.1" @@ -518,12 +523,12 @@ "@istanbuljs/schema@^0.1.2", "@istanbuljs/schema@^0.1.3": version "0.1.3" - resolved "https://registry.yarnpkg.com/@istanbuljs/schema/-/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98" + resolved "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz" integrity sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA== "@jest/console@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/console/-/console-29.7.0.tgz#cd4822dbdb84529265c5a2bdb529a3c9cc950ffc" + resolved "https://registry.npmjs.org/@jest/console/-/console-29.7.0.tgz" integrity sha512-5Ni4CU7XHQi32IJ398EEP4RrB8eV09sXP2ROqD4bksHrnTree52PsxvX8tpL8LvTZ3pFzXyPbNQReSN41CAhOg== dependencies: "@jest/types" "^29.6.3" @@ -535,7 +540,7 @@ "@jest/core@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/core/-/core-29.7.0.tgz#b6cccc239f30ff36609658c5a5e2291757ce448f" + resolved "https://registry.npmjs.org/@jest/core/-/core-29.7.0.tgz" integrity sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg== dependencies: "@jest/console" "^29.7.0" @@ -569,7 +574,7 @@ "@jest/environment@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/environment/-/environment-29.7.0.tgz#24d61f54ff1f786f3cd4073b4b94416383baf2a7" + resolved "https://registry.npmjs.org/@jest/environment/-/environment-29.7.0.tgz" integrity sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw== dependencies: "@jest/fake-timers" "^29.7.0" @@ -579,14 +584,14 @@ "@jest/expect-utils@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/expect-utils/-/expect-utils-29.7.0.tgz#023efe5d26a8a70f21677d0a1afc0f0a44e3a1c6" + resolved "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-29.7.0.tgz" integrity sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA== dependencies: jest-get-type "^29.6.3" "@jest/expect@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/expect/-/expect-29.7.0.tgz#76a3edb0cb753b70dfbfe23283510d3d45432bf2" + resolved "https://registry.npmjs.org/@jest/expect/-/expect-29.7.0.tgz" integrity sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ== dependencies: expect "^29.7.0" @@ -594,7 +599,7 @@ "@jest/fake-timers@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/fake-timers/-/fake-timers-29.7.0.tgz#fd91bf1fffb16d7d0d24a426ab1a47a49881a565" + resolved "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-29.7.0.tgz" integrity sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ== dependencies: "@jest/types" "^29.6.3" @@ -606,7 +611,7 @@ "@jest/globals@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/globals/-/globals-29.7.0.tgz#8d9290f9ec47ff772607fa864ca1d5a2efae1d4d" + resolved "https://registry.npmjs.org/@jest/globals/-/globals-29.7.0.tgz" integrity sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ== dependencies: "@jest/environment" "^29.7.0" @@ -616,7 +621,7 @@ "@jest/reporters@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/reporters/-/reporters-29.7.0.tgz#04b262ecb3b8faa83b0b3d321623972393e8f4c7" + resolved "https://registry.npmjs.org/@jest/reporters/-/reporters-29.7.0.tgz" integrity sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg== dependencies: "@bcoe/v8-coverage" "^0.2.3" @@ -646,14 +651,14 @@ "@jest/schemas@^29.6.3": version "29.6.3" - resolved "https://registry.yarnpkg.com/@jest/schemas/-/schemas-29.6.3.tgz#430b5ce8a4e0044a7e3819663305a7b3091c8e03" + resolved "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz" integrity sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA== dependencies: "@sinclair/typebox" "^0.27.8" "@jest/source-map@^29.6.3": version "29.6.3" - resolved "https://registry.yarnpkg.com/@jest/source-map/-/source-map-29.6.3.tgz#d90ba772095cf37a34a5eb9413f1b562a08554c4" + resolved "https://registry.npmjs.org/@jest/source-map/-/source-map-29.6.3.tgz" integrity sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw== dependencies: "@jridgewell/trace-mapping" "^0.3.18" @@ -662,7 +667,7 @@ "@jest/test-result@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/test-result/-/test-result-29.7.0.tgz#8db9a80aa1a097bb2262572686734baed9b1657c" + resolved "https://registry.npmjs.org/@jest/test-result/-/test-result-29.7.0.tgz" integrity sha512-Fdx+tv6x1zlkJPcWXmMDAG2HBnaR9XPSd5aDWQVsfrZmLVT3lU1cwyxLgRmXR9yrq4NBoEm9BMsfgFzTQAbJYA== dependencies: "@jest/console" "^29.7.0" @@ -672,7 +677,7 @@ "@jest/test-sequencer@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/test-sequencer/-/test-sequencer-29.7.0.tgz#6cef977ce1d39834a3aea887a1726628a6f072ce" + resolved "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-29.7.0.tgz" integrity sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw== dependencies: "@jest/test-result" "^29.7.0" @@ -682,7 +687,7 @@ "@jest/transform@^29.7.0": version "29.7.0" - resolved "https://registry.yarnpkg.com/@jest/transform/-/transform-29.7.0.tgz#df2dd9c346c7d7768b8a06639994640c642e284c" + resolved "https://registry.npmjs.org/@jest/transform/-/transform-29.7.0.tgz" integrity sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw== dependencies: "@babel/core" "^7.11.6" @@ -703,7 +708,7 @@ "@jest/types@^29.6.3": version "29.6.3" - resolved "https://registry.yarnpkg.com/@jest/types/-/types-29.6.3.tgz#1131f8cf634e7e84c5e77bab12f052af585fba59" + resolved "https://registry.npmjs.org/@jest/types/-/types-29.6.3.tgz" integrity sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw== dependencies: "@jest/schemas" "^29.6.3" @@ -731,7 +736,7 @@ "@jridgewell/resolve-uri@^3.1.0": version "3.1.2" - resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz#7a0ee601f60f99a20c7c7c5ff0c80388c1189bd6" + resolved "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz" integrity sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw== "@jridgewell/source-map@^0.3.3": @@ -787,31 +792,31 @@ "@sinclair/typebox@^0.27.8": version "0.27.8" - resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.27.8.tgz#6667fac16c436b5434a387a34dedb013198f6e6e" + resolved "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz" integrity sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA== "@sinonjs/commons@^3.0.0": version "3.0.1" - resolved "https://registry.yarnpkg.com/@sinonjs/commons/-/commons-3.0.1.tgz#1029357e44ca901a615585f6d27738dbc89084cd" + resolved "https://registry.npmjs.org/@sinonjs/commons/-/commons-3.0.1.tgz" integrity sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ== dependencies: type-detect "4.0.8" "@sinonjs/fake-timers@^10.0.2": version "10.3.0" - resolved "https://registry.yarnpkg.com/@sinonjs/fake-timers/-/fake-timers-10.3.0.tgz#55fdff1ecab9f354019129daf4df0dd4d923ea66" + resolved "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-10.3.0.tgz" integrity sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA== dependencies: "@sinonjs/commons" "^3.0.0" "@tootallnate/once@2": version "2.0.0" - resolved "https://registry.yarnpkg.com/@tootallnate/once/-/once-2.0.0.tgz#f544a148d3ab35801c1f633a7441fd87c2e484bf" + resolved "https://registry.npmjs.org/@tootallnate/once/-/once-2.0.0.tgz" integrity sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A== "@types/babel__core@^7.1.14": version "7.20.5" - resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.20.5.tgz#3df15f27ba85319caa07ba08d0721889bb39c017" + resolved "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz" integrity sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA== dependencies: "@babel/parser" "^7.20.7" @@ -822,14 +827,14 @@ "@types/babel__generator@*": version "7.27.0" - resolved "https://registry.yarnpkg.com/@types/babel__generator/-/babel__generator-7.27.0.tgz#b5819294c51179957afaec341442f9341e4108a9" + resolved "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz" integrity sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg== dependencies: "@babel/types" "^7.0.0" "@types/babel__template@*": version "7.4.4" - resolved "https://registry.yarnpkg.com/@types/babel__template/-/babel__template-7.4.4.tgz#5672513701c1b2199bc6dad636a9d7491586766f" + resolved "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz" integrity sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A== dependencies: "@babel/parser" "^7.1.0" @@ -849,7 +854,7 @@ "@types/eslint-scope@^3.7.7": version "3.7.7" - resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.7.tgz#3108bd5f18b0cdb277c867b3dd449c9ed7079ac5" + resolved "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz" integrity sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg== dependencies: "@types/eslint" "*" @@ -857,7 +862,7 @@ "@types/eslint@*": version "9.6.1" - resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-9.6.1.tgz#d5795ad732ce81715f27f75da913004a56751584" + resolved "https://registry.npmjs.org/@types/eslint/-/eslint-9.6.1.tgz" integrity sha512-FXx2pKgId/WyYo2jXw63kk7/+TY7u7AziEJxJAnSFzHlqTAS3Ync6SvgYAN/k4/PQpnnVuzoMuVnByKK2qp0ag== dependencies: "@types/estree" "*" @@ -865,38 +870,38 @@ "@types/estree@*", "@types/estree@^1.0.8": version "1.0.8" - resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.8.tgz#958b91c991b1867ced318bedea0e215ee050726e" + resolved "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz" integrity sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w== "@types/graceful-fs@^4.1.3": version "4.1.9" - resolved "https://registry.yarnpkg.com/@types/graceful-fs/-/graceful-fs-4.1.9.tgz#2a06bc0f68a20ab37b3e36aa238be6abdf49e8b4" + resolved "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.9.tgz" integrity sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ== dependencies: "@types/node" "*" "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0", "@types/istanbul-lib-coverage@^2.0.1": version "2.0.6" - resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz#7739c232a1fee9b4d3ce8985f314c0c6d33549d7" + resolved "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz" integrity sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w== "@types/istanbul-lib-report@*": version "3.0.3" - resolved "https://registry.yarnpkg.com/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz#53047614ae72e19fc0401d872de3ae2b4ce350bf" + resolved "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz" integrity sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA== dependencies: "@types/istanbul-lib-coverage" "*" "@types/istanbul-reports@^3.0.0": version "3.0.4" - resolved "https://registry.yarnpkg.com/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz#0f03e3d2f670fbdac586e34b433783070cc16f54" + resolved "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz" integrity sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ== dependencies: "@types/istanbul-lib-report" "*" "@types/jest@^29.5.14": version "29.5.14" - resolved "https://registry.yarnpkg.com/@types/jest/-/jest-29.5.14.tgz#2b910912fa1d6856cadcd0c1f95af7df1d6049e5" + resolved "https://registry.npmjs.org/@types/jest/-/jest-29.5.14.tgz" integrity sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ== dependencies: expect "^29.0.0" @@ -904,7 +909,7 @@ "@types/jsdom@^20.0.0": version "20.0.1" - resolved "https://registry.yarnpkg.com/@types/jsdom/-/jsdom-20.0.1.tgz#07c14bc19bd2f918c1929541cdaacae894744808" + resolved "https://registry.npmjs.org/@types/jsdom/-/jsdom-20.0.1.tgz" integrity sha512-d0r18sZPmMQr1eG35u12FZfhIXNrnsPU/g5wvRKCUf/tOGilKKwYMYGqh33BNR6ba+2gkHw1EUiHoN3mn7E5IQ== dependencies: "@types/node" "*" @@ -913,7 +918,7 @@ "@types/json-schema@*", "@types/json-schema@^7.0.15", "@types/json-schema@^7.0.9": version "7.0.15" - resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.15.tgz#596a1747233694d50f6ad8a7869fcb6f56cf5841" + resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz" integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA== "@types/node-fetch@^2.6.12": @@ -939,15 +944,15 @@ undici-types "~5.26.4" "@types/readable-stream@^4.0.18": - version "4.0.23" - resolved "https://registry.yarnpkg.com/@types/readable-stream/-/readable-stream-4.0.23.tgz#fcd0f7472f45ceb43154f08f0083ccd1c76e53ce" - integrity sha512-wwXrtQvbMHxCbBgjHaMGEmImFTQxxpfMOR/ZoQnXxB1woqkUbdLGFDgauo00Py9IudiaqSeiBiulSV9i6XIPig== + version "4.0.21" + resolved "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-4.0.21.tgz" + integrity sha512-19eKVv9tugr03IgfXlA9UVUVRbW6IuqRO5B92Dl4a6pT7K8uaGrNS0GkxiZD0BOk6PLuXl5FhWl//eX/pzYdTQ== dependencies: "@types/node" "*" "@types/stack-utils@^2.0.0": version "2.0.3" - resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-2.0.3.tgz#6209321eb2c1712a7e7466422b8cb1fc0d9dd5d8" + resolved "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.3.tgz" integrity sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw== "@types/statuses@^2.0.4": @@ -957,24 +962,24 @@ "@types/tough-cookie@*": version "4.0.5" - resolved "https://registry.yarnpkg.com/@types/tough-cookie/-/tough-cookie-4.0.5.tgz#cb6e2a691b70cb177c6e3ae9c1d2e8b2ea8cd304" + resolved "https://registry.npmjs.org/@types/tough-cookie/-/tough-cookie-4.0.5.tgz" integrity sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA== "@types/yargs-parser@*": version "21.0.3" - resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-21.0.3.tgz#815e30b786d2e8f0dcd85fd5bcf5e1a04d008f15" + resolved "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz" integrity sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ== "@types/yargs@^17.0.8": - version "17.0.35" - resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-17.0.35.tgz#07013e46aa4d7d7d50a49e15604c1c5340d4eb24" - integrity sha512-qUHkeCyQFxMXg79wQfTtfndEC+N9ZZg76HJftDJp+qH2tV7Gj4OJi7l+PiWwJ+pWtW8GwSmqsDj/oymhrTWXjg== + version "17.0.33" + resolved "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz" + integrity sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA== dependencies: "@types/yargs-parser" "*" "@webassemblyjs/ast@1.14.1", "@webassemblyjs/ast@^1.14.1": version "1.14.1" - resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.14.1.tgz#a9f6a07f2b03c95c8d38c4536a1fdfb521ff55b6" + resolved "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz" integrity sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ== dependencies: "@webassemblyjs/helper-numbers" "1.13.2" @@ -982,22 +987,22 @@ "@webassemblyjs/floating-point-hex-parser@1.13.2": version "1.13.2" - resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz#fcca1eeddb1cc4e7b6eed4fc7956d6813b21b9fb" + resolved "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz" integrity sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA== "@webassemblyjs/helper-api-error@1.13.2": version "1.13.2" - resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz#e0a16152248bc38daee76dd7e21f15c5ef3ab1e7" + resolved "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz" integrity sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ== "@webassemblyjs/helper-buffer@1.14.1": version "1.14.1" - resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz#822a9bc603166531f7d5df84e67b5bf99b72b96b" + resolved "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz" integrity sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA== "@webassemblyjs/helper-numbers@1.13.2": version "1.13.2" - resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz#dbd932548e7119f4b8a7877fd5a8d20e63490b2d" + resolved "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz" integrity sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA== dependencies: "@webassemblyjs/floating-point-hex-parser" "1.13.2" @@ -1006,12 +1011,12 @@ "@webassemblyjs/helper-wasm-bytecode@1.13.2": version "1.13.2" - resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz#e556108758f448aae84c850e593ce18a0eb31e0b" + resolved "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz" integrity sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA== "@webassemblyjs/helper-wasm-section@1.14.1": version "1.14.1" - resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz#9629dda9c4430eab54b591053d6dc6f3ba050348" + resolved "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz" integrity sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw== dependencies: "@webassemblyjs/ast" "1.14.1" @@ -1021,26 +1026,26 @@ "@webassemblyjs/ieee754@1.13.2": version "1.13.2" - resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz#1c5eaace1d606ada2c7fd7045ea9356c59ee0dba" + resolved "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz" integrity sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw== dependencies: "@xtuc/ieee754" "^1.2.0" "@webassemblyjs/leb128@1.13.2": version "1.13.2" - resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.13.2.tgz#57c5c3deb0105d02ce25fa3fd74f4ebc9fd0bbb0" + resolved "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.13.2.tgz" integrity sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw== dependencies: "@xtuc/long" "4.2.2" "@webassemblyjs/utf8@1.13.2": version "1.13.2" - resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.13.2.tgz#917a20e93f71ad5602966c2d685ae0c6c21f60f1" + resolved "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.13.2.tgz" integrity sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ== "@webassemblyjs/wasm-edit@^1.14.1": version "1.14.1" - resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz#ac6689f502219b59198ddec42dcd496b1004d597" + resolved "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz" integrity sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ== dependencies: "@webassemblyjs/ast" "1.14.1" @@ -1054,7 +1059,7 @@ "@webassemblyjs/wasm-gen@1.14.1": version "1.14.1" - resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz#991e7f0c090cb0bb62bbac882076e3d219da9570" + resolved "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz" integrity sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg== dependencies: "@webassemblyjs/ast" "1.14.1" @@ -1065,7 +1070,7 @@ "@webassemblyjs/wasm-opt@1.14.1": version "1.14.1" - resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz#e6f71ed7ccae46781c206017d3c14c50efa8106b" + resolved "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz" integrity sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw== dependencies: "@webassemblyjs/ast" "1.14.1" @@ -1075,7 +1080,7 @@ "@webassemblyjs/wasm-parser@1.14.1", "@webassemblyjs/wasm-parser@^1.14.1": version "1.14.1" - resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz#b3e13f1893605ca78b52c68e54cf6a865f90b9fb" + resolved "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz" integrity sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ== dependencies: "@webassemblyjs/ast" "1.14.1" @@ -1087,7 +1092,7 @@ "@webassemblyjs/wast-printer@1.14.1": version "1.14.1" - resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz#3bb3e9638a8ae5fdaf9610e7a06b4d9f9aa6fe07" + resolved "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz" integrity sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw== dependencies: "@webassemblyjs/ast" "1.14.1" @@ -1095,29 +1100,29 @@ "@xtuc/ieee754@^1.2.0": version "1.2.0" - resolved "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790" + resolved "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz" integrity sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA== "@xtuc/long@4.2.2": version "4.2.2" - resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.2.tgz#d291c6a4e97989b5c61d9acf396ae4fe133a718d" + resolved "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz" integrity sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ== abab@^2.0.6: version "2.0.6" - resolved "https://registry.yarnpkg.com/abab/-/abab-2.0.6.tgz#41b80f2c871d19686216b82309231cfd3cb3d291" + resolved "https://registry.npmjs.org/abab/-/abab-2.0.6.tgz" integrity sha512-j2afSsaIENvHZN2B8GOpF566vZ5WVk5opAiMTvWgaQT8DkbOqsTfvNAvHoRGU2zzP8cPoqys+xHTRDWW8L+/BA== abort-controller@^3.0.0: version "3.0.0" - resolved "https://registry.yarnpkg.com/abort-controller/-/abort-controller-3.0.0.tgz#eaf54d53b62bae4138e809ca225c8439a6efb392" + resolved "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz" integrity sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg== dependencies: event-target-shim "^5.0.0" acorn-globals@^7.0.0: version "7.0.1" - resolved "https://registry.yarnpkg.com/acorn-globals/-/acorn-globals-7.0.1.tgz#0dbf05c44fa7c94332914c02066d5beff62c40c3" + resolved "https://registry.npmjs.org/acorn-globals/-/acorn-globals-7.0.1.tgz" integrity sha512-umOSDSDrfHbTNPuNpC2NSnnA3LUrqpevPb4T9jRx4MagXNS0rs+gwiTcAvqCRmsD6utzsrzNt+ebm00SNWiC3Q== dependencies: acorn "^8.1.0" @@ -1125,45 +1130,45 @@ acorn-globals@^7.0.0: acorn-import-phases@^1.0.3: version "1.0.4" - resolved "https://registry.yarnpkg.com/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz#16eb850ba99a056cb7cbfe872ffb8972e18c8bd7" + resolved "https://registry.npmjs.org/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz" integrity sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ== acorn-walk@^8.0.2: version "8.3.4" - resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.3.4.tgz#794dd169c3977edf4ba4ea47583587c5866236b7" + resolved "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz" integrity sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g== dependencies: acorn "^8.11.0" acorn@^8.1.0, acorn@^8.11.0, acorn@^8.15.0, acorn@^8.8.1: version "8.15.0" - resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.15.0.tgz#a360898bc415edaac46c8241f6383975b930b816" + resolved "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz" integrity sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg== agent-base@6: version "6.0.2" - resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-6.0.2.tgz#49fff58577cfee3f37176feab4c22e00f86d7f77" + resolved "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz" integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ== dependencies: debug "4" ajv-formats@^2.1.1: version "2.1.1" - resolved "https://registry.yarnpkg.com/ajv-formats/-/ajv-formats-2.1.1.tgz#6e669400659eb74973bbf2e33327180a0996b520" + resolved "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz" integrity sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA== dependencies: ajv "^8.0.0" ajv-keywords@^5.1.0: version "5.1.0" - resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-5.1.0.tgz#69d4d385a4733cdbeab44964a1170a88f87f0e16" + resolved "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz" integrity sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw== dependencies: fast-deep-equal "^3.1.3" ajv@^8.0.0, ajv@^8.9.0: version "8.17.1" - resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.17.1.tgz#37d9a5c776af6bc92d7f4f9510eba4c0a60d11a6" + resolved "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz" integrity sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g== dependencies: fast-deep-equal "^3.1.3" @@ -1173,31 +1178,31 @@ ajv@^8.0.0, ajv@^8.9.0: ansi-escapes@^4.2.1: version "4.3.2" - resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e" + resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz" integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ== dependencies: type-fest "^0.21.3" ansi-regex@^5.0.1: version "5.0.1" - resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" + resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz" integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== ansi-styles@^4.0.0, ansi-styles@^4.1.0: version "4.3.0" - resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" + resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz" integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== dependencies: color-convert "^2.0.1" ansi-styles@^5.0.0: version "5.2.0" - resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b" + resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz" integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA== anymatch@^3.0.3: version "3.1.3" - resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e" + resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz" integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== dependencies: normalize-path "^3.0.0" @@ -1205,19 +1210,24 @@ anymatch@^3.0.3: argparse@^1.0.7: version "1.0.10" - resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911" + resolved "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz" integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg== dependencies: sprintf-js "~1.0.2" +async@^3.2.6: + version "3.2.6" + resolved "https://registry.yarnpkg.com/async/-/async-3.2.6.tgz#1b0728e14929d51b85b449b7f06e27c1145e38ce" + integrity sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA== + asynckit@^0.4.0: version "0.4.0" - resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79" + resolved "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz" integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q== babel-jest@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/babel-jest/-/babel-jest-29.7.0.tgz#f4369919225b684c56085998ac63dbd05be020d5" + resolved "https://registry.npmjs.org/babel-jest/-/babel-jest-29.7.0.tgz" integrity sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg== dependencies: "@jest/transform" "^29.7.0" @@ -1230,7 +1240,7 @@ babel-jest@^29.7.0: babel-plugin-istanbul@^6.1.1: version "6.1.1" - resolved "https://registry.yarnpkg.com/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz#fa88ec59232fd9b4e36dbbc540a8ec9a9b47da73" + resolved "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz" integrity sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA== dependencies: "@babel/helper-plugin-utils" "^7.0.0" @@ -1241,7 +1251,7 @@ babel-plugin-istanbul@^6.1.1: babel-plugin-jest-hoist@^29.6.3: version "29.6.3" - resolved "https://registry.yarnpkg.com/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.6.3.tgz#aadbe943464182a8922c3c927c3067ff40d24626" + resolved "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.6.3.tgz" integrity sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg== dependencies: "@babel/template" "^7.3.3" @@ -1272,7 +1282,7 @@ babel-preset-current-node-syntax@^1.0.0: babel-preset-jest@^29.6.3: version "29.6.3" - resolved "https://registry.yarnpkg.com/babel-preset-jest/-/babel-preset-jest-29.6.3.tgz#fa05fa510e7d493896d7b0dd2033601c840f171c" + resolved "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-29.6.3.tgz" integrity sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA== dependencies: babel-plugin-jest-hoist "^29.6.3" @@ -1280,12 +1290,12 @@ babel-preset-jest@^29.6.3: balanced-match@^1.0.0: version "1.0.2" - resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" + resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz" integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== base64-js@^1.3.1: version "1.5.1" - resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a" + resolved "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz" integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== baseline-browser-mapping@^2.9.0: @@ -1295,15 +1305,22 @@ baseline-browser-mapping@^2.9.0: brace-expansion@^1.1.7: version "1.1.12" - resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.12.tgz#ab9b454466e5a8cc3a187beaad580412a9c5b843" + resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz" integrity sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg== dependencies: balanced-match "^1.0.0" concat-map "0.0.1" +brace-expansion@^2.0.1: + version "2.0.2" + resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.2.tgz#54fc53237a613d854c7bd37463aad17df87214e7" + integrity sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ== + dependencies: + balanced-match "^1.0.0" + braces@^3.0.3: version "3.0.3" - resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.3.tgz#490332f40919452272d55a8480adc0c441358789" + resolved "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz" integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA== dependencies: fill-range "^7.1.1" @@ -1321,26 +1338,26 @@ browserslist@^4.24.0, browserslist@^4.28.1: bs-logger@^0.2.6: version "0.2.6" - resolved "https://registry.yarnpkg.com/bs-logger/-/bs-logger-0.2.6.tgz#eb7d365307a72cf974cc6cda76b68354ad336bd8" + resolved "https://registry.npmjs.org/bs-logger/-/bs-logger-0.2.6.tgz" integrity sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog== dependencies: fast-json-stable-stringify "2.x" bser@2.1.1: version "2.1.1" - resolved "https://registry.yarnpkg.com/bser/-/bser-2.1.1.tgz#e6787da20ece9d07998533cfd9de6f5c38f4bc05" + resolved "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz" integrity sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ== dependencies: node-int64 "^0.4.0" buffer-from@^1.0.0: version "1.1.2" - resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5" + resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz" integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ== buffer@^6.0.3: version "6.0.3" - resolved "https://registry.yarnpkg.com/buffer/-/buffer-6.0.3.tgz#2ace578459cc8fbe2a70aaa8f52ee63b6a74c6c6" + resolved "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz" integrity sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA== dependencies: base64-js "^1.3.1" @@ -1348,7 +1365,7 @@ buffer@^6.0.3: call-bind-apply-helpers@^1.0.1, call-bind-apply-helpers@^1.0.2: version "1.0.2" - resolved "https://registry.yarnpkg.com/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz#4b5428c222be985d79c3d82657479dbe0b59b2d6" + resolved "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz" integrity sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ== dependencies: es-errors "^1.3.0" @@ -1356,17 +1373,17 @@ call-bind-apply-helpers@^1.0.1, call-bind-apply-helpers@^1.0.2: callsites@^3.0.0: version "3.1.0" - resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73" + resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz" integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== camelcase@^5.3.1: version "5.3.1" - resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320" + resolved "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz" integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg== camelcase@^6.2.0: version "6.3.0" - resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a" + resolved "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz" integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== caniuse-lite@^1.0.30001759: @@ -1376,7 +1393,7 @@ caniuse-lite@^1.0.30001759: chalk@^4.0.0, chalk@^4.1.0: version "4.1.2" - resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01" + resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz" integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== dependencies: ansi-styles "^4.1.0" @@ -1384,22 +1401,22 @@ chalk@^4.0.0, chalk@^4.1.0: char-regex@^1.0.2: version "1.0.2" - resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf" + resolved "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz" integrity sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw== chrome-trace-event@^1.0.2: version "1.0.4" - resolved "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz#05bffd7ff928465093314708c93bdfa9bd1f0f5b" + resolved "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz" integrity sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ== ci-info@^3.2.0: version "3.9.0" - resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.9.0.tgz#4279a62028a7b1f262f3473fc9605f5e218c59b4" + resolved "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz" integrity sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ== cjs-module-lexer@^1.0.0: version "1.4.3" - resolved "https://registry.yarnpkg.com/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz#0f79731eb8cfe1ec72acd4066efac9d61991b00d" + resolved "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz" integrity sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q== cli-width@^4.1.0: @@ -1409,7 +1426,7 @@ cli-width@^4.1.0: cliui@^8.0.1: version "8.0.1" - resolved "https://registry.yarnpkg.com/cliui/-/cliui-8.0.1.tgz#0c04b075db02cbfe60dc8e6cf2f5486b1a3608aa" + resolved "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz" integrity sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ== dependencies: string-width "^4.2.0" @@ -1418,7 +1435,7 @@ cliui@^8.0.1: co@^4.6.0: version "4.6.0" - resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184" + resolved "https://registry.npmjs.org/co/-/co-4.6.0.tgz" integrity sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ== collect-v8-coverage@^1.0.0: @@ -1428,36 +1445,36 @@ collect-v8-coverage@^1.0.0: color-convert@^2.0.1: version "2.0.1" - resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3" + resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz" integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== dependencies: color-name "~1.1.4" color-name@~1.1.4: version "1.1.4" - resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" + resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz" integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== combined-stream@^1.0.8: version "1.0.8" - resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f" + resolved "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz" integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg== dependencies: delayed-stream "~1.0.0" commander@^2.20.0: version "2.20.3" - resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33" + resolved "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz" integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ== concat-map@0.0.1: version "0.0.1" - resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" + resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz" integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== convert-source-map@^2.0.0: version "2.0.0" - resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-2.0.0.tgz#4b560f649fc4e918dd0ab75cf4961e8bc882d82a" + resolved "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz" integrity sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg== cookie@^0.7.2: @@ -1467,7 +1484,7 @@ cookie@^0.7.2: create-jest@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/create-jest/-/create-jest-29.7.0.tgz#a355c5b3cb1e1af02ba177fe7afd7feee49a5320" + resolved "https://registry.npmjs.org/create-jest/-/create-jest-29.7.0.tgz" integrity sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q== dependencies: "@jest/types" "^29.6.3" @@ -1480,7 +1497,7 @@ create-jest@^29.7.0: cross-spawn@^7.0.3: version "7.0.6" - resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.6.tgz#8a58fe78f00dcd70c370451759dfbfaf03e8ee9f" + resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz" integrity sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA== dependencies: path-key "^3.1.0" @@ -1489,24 +1506,24 @@ cross-spawn@^7.0.3: cssom@^0.5.0: version "0.5.0" - resolved "https://registry.yarnpkg.com/cssom/-/cssom-0.5.0.tgz#d254fa92cd8b6fbd83811b9fbaed34663cc17c36" + resolved "https://registry.npmjs.org/cssom/-/cssom-0.5.0.tgz" integrity sha512-iKuQcq+NdHqlAcwUY0o/HL69XQrUaQdMjmStJ8JFmUaiiQErlhrmuigkg/CU4E2J0IyUKUrMAgl36TvN67MqTw== cssom@~0.3.6: version "0.3.8" - resolved "https://registry.yarnpkg.com/cssom/-/cssom-0.3.8.tgz#9f1276f5b2b463f2114d3f2c75250af8c1a36f4a" + resolved "https://registry.npmjs.org/cssom/-/cssom-0.3.8.tgz" integrity sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg== cssstyle@^2.3.0: version "2.3.0" - resolved "https://registry.yarnpkg.com/cssstyle/-/cssstyle-2.3.0.tgz#ff665a0ddbdc31864b09647f34163443d90b0852" + resolved "https://registry.npmjs.org/cssstyle/-/cssstyle-2.3.0.tgz" integrity sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A== dependencies: cssom "~0.3.6" data-urls@^3.0.2: version "3.0.2" - resolved "https://registry.yarnpkg.com/data-urls/-/data-urls-3.0.2.tgz#9cf24a477ae22bcef5cd5f6f0bfbc1d2d3be9143" + resolved "https://registry.npmjs.org/data-urls/-/data-urls-3.0.2.tgz" integrity sha512-Jy/tj3ldjZJo63sVAvg6LHt2mHvl4V6AgRAmNDtLdm7faqtsx+aJG42rsyCo9JCoRVKwPFzKlIPx3DIibwSIaQ== dependencies: abab "^2.0.6" @@ -1522,7 +1539,7 @@ debug@4, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1: decimal.js@^10.4.2: version "10.6.0" - resolved "https://registry.yarnpkg.com/decimal.js/-/decimal.js-10.6.0.tgz#e649a43e3ab953a72192ff5983865e509f37ed9a" + resolved "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz" integrity sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg== dedent@^1.0.0: @@ -1532,40 +1549,47 @@ dedent@^1.0.0: deepmerge@^4.2.2: version "4.3.1" - resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a" + resolved "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz" integrity sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A== delayed-stream@~1.0.0: version "1.0.0" - resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" + resolved "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz" integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ== detect-newline@^3.0.0: version "3.1.0" - resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651" + resolved "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz" integrity sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA== diff-sequences@^29.6.3: version "29.6.3" - resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-29.6.3.tgz#4deaf894d11407c51efc8418012f9e70b84ea921" + resolved "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.6.3.tgz" integrity sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q== domexception@^4.0.0: version "4.0.0" - resolved "https://registry.yarnpkg.com/domexception/-/domexception-4.0.0.tgz#4ad1be56ccadc86fc76d033353999a8037d03673" + resolved "https://registry.npmjs.org/domexception/-/domexception-4.0.0.tgz" integrity sha512-A2is4PLG+eeSfoTMA95/s4pvAoSo2mKtiM5jlHkAVewmiO8ISFTFKZjH7UAM1Atli/OT/7JHOrJRJiMKUZKYBw== dependencies: webidl-conversions "^7.0.0" dunder-proto@^1.0.1: version "1.0.1" - resolved "https://registry.yarnpkg.com/dunder-proto/-/dunder-proto-1.0.1.tgz#d7ae667e1dc83482f8b70fd0f6eefc50da30f58a" + resolved "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz" integrity sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A== dependencies: call-bind-apply-helpers "^1.0.1" es-errors "^1.3.0" gopd "^1.2.0" +ejs@^3.1.10: + version "3.1.10" + resolved "https://registry.yarnpkg.com/ejs/-/ejs-3.1.10.tgz#69ab8358b14e896f80cc39e62087b88500c3ac3b" + integrity sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA== + dependencies: + jake "^10.8.5" + electron-to-chromium@^1.5.263: version "1.5.267" resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.5.267.tgz#5d84f2df8cdb6bfe7e873706bb21bd4bfb574dc7" @@ -1573,12 +1597,12 @@ electron-to-chromium@^1.5.263: emittery@^0.13.1: version "0.13.1" - resolved "https://registry.yarnpkg.com/emittery/-/emittery-0.13.1.tgz#c04b8c3457490e0847ae51fced3af52d338e3dad" + resolved "https://registry.npmjs.org/emittery/-/emittery-0.13.1.tgz" integrity sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ== emoji-regex@^8.0.0: version "8.0.0" - resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" + resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz" integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== enhanced-resolve@^5.0.0, enhanced-resolve@^5.17.4: @@ -1591,7 +1615,7 @@ enhanced-resolve@^5.0.0, enhanced-resolve@^5.17.4: entities@^6.0.0: version "6.0.1" - resolved "https://registry.yarnpkg.com/entities/-/entities-6.0.1.tgz#c28c34a43379ca7f61d074130b2f5f7020a30694" + resolved "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz" integrity sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g== error-ex@^1.3.1: @@ -1603,12 +1627,12 @@ error-ex@^1.3.1: es-define-property@^1.0.1: version "1.0.1" - resolved "https://registry.yarnpkg.com/es-define-property/-/es-define-property-1.0.1.tgz#983eb2f9a6724e9303f61addf011c72e09e0b0fa" + resolved "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz" integrity sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g== es-errors@^1.3.0: version "1.3.0" - resolved "https://registry.yarnpkg.com/es-errors/-/es-errors-1.3.0.tgz#05f75a25dab98e4fb1dcd5e1472c0546d5057c8f" + resolved "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz" integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw== es-module-lexer@^2.0.0: @@ -1618,14 +1642,14 @@ es-module-lexer@^2.0.0: es-object-atoms@^1.0.0, es-object-atoms@^1.1.1: version "1.1.1" - resolved "https://registry.yarnpkg.com/es-object-atoms/-/es-object-atoms-1.1.1.tgz#1c4f2c4837327597ce69d2ca190a7fdd172338c1" + resolved "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz" integrity sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA== dependencies: es-errors "^1.3.0" es-set-tostringtag@^2.1.0: version "2.1.0" - resolved "https://registry.yarnpkg.com/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz#f31dbbe0c183b00a6d26eb6325c810c0fd18bd4d" + resolved "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz" integrity sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA== dependencies: es-errors "^1.3.0" @@ -1667,17 +1691,17 @@ esbuild@^0.25.9: escalade@^3.1.1, escalade@^3.2.0: version "3.2.0" - resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.2.0.tgz#011a3f69856ba189dffa7dc8fcce99d2a87903e5" + resolved "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz" integrity sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA== escape-string-regexp@^2.0.0: version "2.0.0" - resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz#a30304e99daa32e23b2fd20f51babd07cffca344" + resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz" integrity sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w== escodegen@^2.0.0: version "2.1.0" - resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-2.1.0.tgz#ba93bbb7a43986d29d6041f99f5262da773e2e17" + resolved "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz" integrity sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w== dependencies: esprima "^4.0.1" @@ -1688,7 +1712,7 @@ escodegen@^2.0.0: eslint-scope@5.1.1: version "5.1.1" - resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c" + resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz" integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw== dependencies: esrecurse "^4.3.0" @@ -1696,44 +1720,44 @@ eslint-scope@5.1.1: esprima@^4.0.0, esprima@^4.0.1: version "4.0.1" - resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71" + resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz" integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== esrecurse@^4.3.0: version "4.3.0" - resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921" + resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz" integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag== dependencies: estraverse "^5.2.0" estraverse@^4.1.1: version "4.3.0" - resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d" + resolved "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz" integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw== estraverse@^5.2.0: version "5.3.0" - resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123" + resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz" integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA== esutils@^2.0.2: version "2.0.3" - resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64" + resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz" integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g== event-target-shim@^5.0.0: version "5.0.1" - resolved "https://registry.yarnpkg.com/event-target-shim/-/event-target-shim-5.0.1.tgz#5d4d3ebdf9583d63a5333ce2deb7480ab2b05789" + resolved "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz" integrity sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ== events@^3.2.0, events@^3.3.0: version "3.3.0" - resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400" + resolved "https://registry.npmjs.org/events/-/events-3.3.0.tgz" integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q== execa@^5.0.0: version "5.1.1" - resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd" + resolved "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz" integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg== dependencies: cross-spawn "^7.0.3" @@ -1748,12 +1772,12 @@ execa@^5.0.0: exit@^0.1.2: version "0.1.2" - resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c" + resolved "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz" integrity sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ== expect@^29.0.0, expect@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/expect/-/expect-29.7.0.tgz#578874590dcb3214514084c08115d8aee61e11bc" + resolved "https://registry.npmjs.org/expect/-/expect-29.7.0.tgz" integrity sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw== dependencies: "@jest/expect-utils" "^29.7.0" @@ -1764,12 +1788,12 @@ expect@^29.0.0, expect@^29.7.0: fast-deep-equal@^3.1.3: version "3.1.3" - resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" + resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz" integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== fast-json-stable-stringify@2.x, fast-json-stable-stringify@^2.1.0: version "2.1.0" - resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633" + resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz" integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== fast-uri@^3.0.1: @@ -1779,30 +1803,37 @@ fast-uri@^3.0.1: fb-watchman@^2.0.0: version "2.0.2" - resolved "https://registry.yarnpkg.com/fb-watchman/-/fb-watchman-2.0.2.tgz#e9524ee6b5c77e9e5001af0f85f3adbb8623255c" + resolved "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz" integrity sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA== dependencies: bser "2.1.1" +filelist@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/filelist/-/filelist-1.0.4.tgz#f78978a1e944775ff9e62e744424f215e58352b5" + integrity sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q== + dependencies: + minimatch "^5.0.1" + fill-range@^7.1.1: version "7.1.1" - resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.1.1.tgz#44265d3cac07e3ea7dc247516380643754a05292" + resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz" integrity sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg== dependencies: to-regex-range "^5.0.1" find-up@^4.0.0, find-up@^4.1.0: version "4.1.0" - resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19" + resolved "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz" integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw== dependencies: locate-path "^5.0.0" path-exists "^4.0.0" form-data@^4.0.0, form-data@^4.0.4: - version "4.0.5" - resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.5.tgz#b49e48858045ff4cbf6b03e1805cebcad3679053" - integrity sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w== + version "4.0.4" + resolved "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz" + integrity sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow== dependencies: asynckit "^0.4.0" combined-stream "^1.0.8" @@ -1812,37 +1843,37 @@ form-data@^4.0.0, form-data@^4.0.4: formdata-node@^6.0.3: version "6.0.3" - resolved "https://registry.yarnpkg.com/formdata-node/-/formdata-node-6.0.3.tgz#48f8e2206ae2befded82af621ef015f08168dc6d" + resolved "https://registry.npmjs.org/formdata-node/-/formdata-node-6.0.3.tgz" integrity sha512-8e1++BCiTzUno9v5IZ2J6bv4RU+3UKDmqWUQD0MIMVCd9AdhWkO1gw57oo1mNEX1dMq2EGI+FbWz4B92pscSQg== fs.realpath@^1.0.0: version "1.0.0" - resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" + resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz" integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== fsevents@^2.3.2: version "2.3.3" - resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6" + resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz" integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw== function-bind@^1.1.2: version "1.1.2" - resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c" + resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz" integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA== gensync@^1.0.0-beta.2: version "1.0.0-beta.2" - resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0" + resolved "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz" integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg== get-caller-file@^2.0.5: version "2.0.5" - resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e" + resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz" integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== get-intrinsic@^1.2.6: version "1.3.0" - resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.3.0.tgz#743f0e3b6964a93a5491ed1bffaae054d7f98d01" + resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz" integrity sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ== dependencies: call-bind-apply-helpers "^1.0.2" @@ -1858,12 +1889,12 @@ get-intrinsic@^1.2.6: get-package-type@^0.1.0: version "0.1.0" - resolved "https://registry.yarnpkg.com/get-package-type/-/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a" + resolved "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz" integrity sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q== get-proto@^1.0.1: version "1.0.1" - resolved "https://registry.yarnpkg.com/get-proto/-/get-proto-1.0.1.tgz#150b3f2743869ef3e851ec0c49d15b1d14d00ee1" + resolved "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz" integrity sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g== dependencies: dunder-proto "^1.0.1" @@ -1871,17 +1902,17 @@ get-proto@^1.0.1: get-stream@^6.0.0: version "6.0.1" - resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7" + resolved "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz" integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg== glob-to-regexp@^0.4.1: version "0.4.1" - resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz#c75297087c851b9a578bd217dd59a92f59fe546e" + resolved "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz" integrity sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw== glob@^7.1.3, glob@^7.1.4: version "7.2.3" - resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b" + resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz" integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== dependencies: fs.realpath "^1.0.0" @@ -1893,12 +1924,12 @@ glob@^7.1.3, glob@^7.1.4: gopd@^1.2.0: version "1.2.0" - resolved "https://registry.yarnpkg.com/gopd/-/gopd-1.2.0.tgz#89f56b8217bdbc8802bd299df6d7f1081d7e51a1" + resolved "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz" integrity sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg== graceful-fs@^4.1.2, graceful-fs@^4.2.11, graceful-fs@^4.2.4, graceful-fs@^4.2.9: version "4.2.11" - resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3" + resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz" integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== graphql@^16.8.1: @@ -1906,38 +1937,26 @@ graphql@^16.8.1: resolved "https://registry.yarnpkg.com/graphql/-/graphql-16.12.0.tgz#28cc2462435b1ac3fdc6976d030cef83a0c13ac7" integrity sha512-DKKrynuQRne0PNpEbzuEdHlYOMksHSUI8Zc9Unei5gTsMNA2/vMpoMz/yKba50pejK56qj98qM0SjYxAKi13gQ== -handlebars@^4.7.8: - version "4.7.8" - resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.7.8.tgz#41c42c18b1be2365439188c77c6afae71c0cd9e9" - integrity sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ== - dependencies: - minimist "^1.2.5" - neo-async "^2.6.2" - source-map "^0.6.1" - wordwrap "^1.0.0" - optionalDependencies: - uglify-js "^3.1.4" - has-flag@^4.0.0: version "4.0.0" - resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b" + resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz" integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== has-symbols@^1.0.3, has-symbols@^1.1.0: version "1.1.0" - resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.1.0.tgz#fc9c6a783a084951d0b971fe1018de813707a338" + resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz" integrity sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ== has-tostringtag@^1.0.2: version "1.0.2" - resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.2.tgz#2cdc42d40bef2e5b4eeab7c01a73c54ce7ab5abc" + resolved "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz" integrity sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw== dependencies: has-symbols "^1.0.3" hasown@^2.0.2: version "2.0.2" - resolved "https://registry.yarnpkg.com/hasown/-/hasown-2.0.2.tgz#003eaf91be7adc372e84ec59dc37252cedb80003" + resolved "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz" integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ== dependencies: function-bind "^1.1.2" @@ -1949,19 +1968,19 @@ headers-polyfill@^4.0.2: html-encoding-sniffer@^3.0.0: version "3.0.0" - resolved "https://registry.yarnpkg.com/html-encoding-sniffer/-/html-encoding-sniffer-3.0.0.tgz#2cb1a8cf0db52414776e5b2a7a04d5dd98158de9" + resolved "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-3.0.0.tgz" integrity sha512-oWv4T4yJ52iKrufjnyZPkrN0CH3QnrUqdB6In1g5Fe1mia8GmF36gnfNySxoZtxD5+NmYw1EElVXiBk93UeskA== dependencies: whatwg-encoding "^2.0.0" html-escaper@^2.0.0: version "2.0.2" - resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453" + resolved "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz" integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg== http-proxy-agent@^5.0.0: version "5.0.0" - resolved "https://registry.yarnpkg.com/http-proxy-agent/-/http-proxy-agent-5.0.0.tgz#5129800203520d434f142bc78ff3c170800f2b43" + resolved "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-5.0.0.tgz" integrity sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w== dependencies: "@tootallnate/once" "2" @@ -1970,7 +1989,7 @@ http-proxy-agent@^5.0.0: https-proxy-agent@^5.0.1: version "5.0.1" - resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz#c59ef224a04fe8b754f3db0063a25ea30d0005d6" + resolved "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz" integrity sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA== dependencies: agent-base "6" @@ -1978,24 +1997,24 @@ https-proxy-agent@^5.0.1: human-signals@^2.1.0: version "2.1.0" - resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0" + resolved "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz" integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw== iconv-lite@0.6.3: version "0.6.3" - resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.6.3.tgz#a52f80bf38da1952eb5c681790719871a1a72501" + resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz" integrity sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw== dependencies: safer-buffer ">= 2.1.2 < 3.0.0" ieee754@^1.2.1: version "1.2.1" - resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352" + resolved "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz" integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== import-local@^3.0.2: version "3.2.0" - resolved "https://registry.yarnpkg.com/import-local/-/import-local-3.2.0.tgz#c3d5c745798c02a6f8b897726aba5100186ee260" + resolved "https://registry.npmjs.org/import-local/-/import-local-3.2.0.tgz" integrity sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA== dependencies: pkg-dir "^4.2.0" @@ -2003,12 +2022,12 @@ import-local@^3.0.2: imurmurhash@^0.1.4: version "0.1.4" - resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea" + resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz" integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA== inflight@^1.0.4: version "1.0.6" - resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" + resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz" integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== dependencies: once "^1.3.0" @@ -2016,12 +2035,12 @@ inflight@^1.0.4: inherits@2: version "2.0.4" - resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" + resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz" integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== is-arrayish@^0.2.1: version "0.2.1" - resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d" + resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz" integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg== is-core-module@^2.16.1: @@ -2033,12 +2052,12 @@ is-core-module@^2.16.1: is-fullwidth-code-point@^3.0.0: version "3.0.0" - resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" + resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz" integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== is-generator-fn@^2.0.0: version "2.1.0" - resolved "https://registry.yarnpkg.com/is-generator-fn/-/is-generator-fn-2.1.0.tgz#7d140adc389aaf3011a8f2a2a4cfa6faadffb118" + resolved "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz" integrity sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ== is-node-process@^1.2.0: @@ -2048,32 +2067,32 @@ is-node-process@^1.2.0: is-number@^7.0.0: version "7.0.0" - resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b" + resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz" integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== is-potential-custom-element-name@^1.0.1: version "1.0.1" - resolved "https://registry.yarnpkg.com/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz#171ed6f19e3ac554394edf78caa05784a45bebb5" + resolved "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz" integrity sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ== is-stream@^2.0.0: version "2.0.1" - resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077" + resolved "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz" integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg== isexe@^2.0.0: version "2.0.0" - resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" + resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz" integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== istanbul-lib-coverage@^3.0.0, istanbul-lib-coverage@^3.2.0: version "3.2.2" - resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz#2d166c4b0644d43a39f04bf6c2edd1e585f31756" + resolved "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz" integrity sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg== istanbul-lib-instrument@^5.0.4: version "5.2.1" - resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz#d10c8885c2125574e1c231cacadf955675e1ce3d" + resolved "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz" integrity sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg== dependencies: "@babel/core" "^7.12.3" @@ -2084,7 +2103,7 @@ istanbul-lib-instrument@^5.0.4: istanbul-lib-instrument@^6.0.0: version "6.0.3" - resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-6.0.3.tgz#fa15401df6c15874bcb2105f773325d78c666765" + resolved "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-6.0.3.tgz" integrity sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q== dependencies: "@babel/core" "^7.23.9" @@ -2095,7 +2114,7 @@ istanbul-lib-instrument@^6.0.0: istanbul-lib-report@^3.0.0: version "3.0.1" - resolved "https://registry.yarnpkg.com/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz#908305bac9a5bd175ac6a74489eafd0fc2445a7d" + resolved "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz" integrity sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw== dependencies: istanbul-lib-coverage "^3.0.0" @@ -2104,7 +2123,7 @@ istanbul-lib-report@^3.0.0: istanbul-lib-source-maps@^4.0.0: version "4.0.1" - resolved "https://registry.yarnpkg.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz#895f3a709fcfba34c6de5a42939022f3e4358551" + resolved "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz" integrity sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw== dependencies: debug "^4.1.1" @@ -2119,9 +2138,18 @@ istanbul-reports@^3.1.3: html-escaper "^2.0.0" istanbul-lib-report "^3.0.0" +jake@^10.8.5: + version "10.9.4" + resolved "https://registry.yarnpkg.com/jake/-/jake-10.9.4.tgz#d626da108c63d5cfb00ab5c25fadc7e0084af8e6" + integrity sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA== + dependencies: + async "^3.2.6" + filelist "^1.0.4" + picocolors "^1.1.1" + jest-changed-files@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-changed-files/-/jest-changed-files-29.7.0.tgz#1c06d07e77c78e1585d020424dedc10d6e17ac3a" + resolved "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-29.7.0.tgz" integrity sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w== dependencies: execa "^5.0.0" @@ -2130,7 +2158,7 @@ jest-changed-files@^29.7.0: jest-circus@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-circus/-/jest-circus-29.7.0.tgz#b6817a45fcc835d8b16d5962d0c026473ee3668a" + resolved "https://registry.npmjs.org/jest-circus/-/jest-circus-29.7.0.tgz" integrity sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw== dependencies: "@jest/environment" "^29.7.0" @@ -2156,7 +2184,7 @@ jest-circus@^29.7.0: jest-cli@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-cli/-/jest-cli-29.7.0.tgz#5592c940798e0cae677eec169264f2d839a37995" + resolved "https://registry.npmjs.org/jest-cli/-/jest-cli-29.7.0.tgz" integrity sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg== dependencies: "@jest/core" "^29.7.0" @@ -2173,7 +2201,7 @@ jest-cli@^29.7.0: jest-config@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-config/-/jest-config-29.7.0.tgz#bcbda8806dbcc01b1e316a46bb74085a84b0245f" + resolved "https://registry.npmjs.org/jest-config/-/jest-config-29.7.0.tgz" integrity sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ== dependencies: "@babel/core" "^7.11.6" @@ -2201,7 +2229,7 @@ jest-config@^29.7.0: jest-diff@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-29.7.0.tgz#017934a66ebb7ecf6f205e84699be10afd70458a" + resolved "https://registry.npmjs.org/jest-diff/-/jest-diff-29.7.0.tgz" integrity sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw== dependencies: chalk "^4.0.0" @@ -2211,14 +2239,14 @@ jest-diff@^29.7.0: jest-docblock@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-docblock/-/jest-docblock-29.7.0.tgz#8fddb6adc3cdc955c93e2a87f61cfd350d5d119a" + resolved "https://registry.npmjs.org/jest-docblock/-/jest-docblock-29.7.0.tgz" integrity sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g== dependencies: detect-newline "^3.0.0" jest-each@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-each/-/jest-each-29.7.0.tgz#162a9b3f2328bdd991beaabffbb74745e56577d1" + resolved "https://registry.npmjs.org/jest-each/-/jest-each-29.7.0.tgz" integrity sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ== dependencies: "@jest/types" "^29.6.3" @@ -2229,7 +2257,7 @@ jest-each@^29.7.0: jest-environment-jsdom@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-environment-jsdom/-/jest-environment-jsdom-29.7.0.tgz#d206fa3551933c3fd519e5dfdb58a0f5139a837f" + resolved "https://registry.npmjs.org/jest-environment-jsdom/-/jest-environment-jsdom-29.7.0.tgz" integrity sha512-k9iQbsf9OyOfdzWH8HDmrRT0gSIcX+FLNW7IQq94tFX0gynPwqDTW0Ho6iMVNjGz/nb+l/vW3dWM2bbLLpkbXA== dependencies: "@jest/environment" "^29.7.0" @@ -2243,7 +2271,7 @@ jest-environment-jsdom@^29.7.0: jest-environment-node@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-environment-node/-/jest-environment-node-29.7.0.tgz#0b93e111dda8ec120bc8300e6d1fb9576e164376" + resolved "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-29.7.0.tgz" integrity sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw== dependencies: "@jest/environment" "^29.7.0" @@ -2255,12 +2283,12 @@ jest-environment-node@^29.7.0: jest-get-type@^29.6.3: version "29.6.3" - resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-29.6.3.tgz#36f499fdcea197c1045a127319c0481723908fd1" + resolved "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.6.3.tgz" integrity sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw== jest-haste-map@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-haste-map/-/jest-haste-map-29.7.0.tgz#3c2396524482f5a0506376e6c858c3bbcc17b104" + resolved "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-29.7.0.tgz" integrity sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA== dependencies: "@jest/types" "^29.6.3" @@ -2279,7 +2307,7 @@ jest-haste-map@^29.7.0: jest-leak-detector@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-leak-detector/-/jest-leak-detector-29.7.0.tgz#5b7ec0dadfdfec0ca383dc9aa016d36b5ea4c728" + resolved "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-29.7.0.tgz" integrity sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw== dependencies: jest-get-type "^29.6.3" @@ -2287,7 +2315,7 @@ jest-leak-detector@^29.7.0: jest-matcher-utils@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-29.7.0.tgz#ae8fec79ff249fd592ce80e3ee474e83a6c44f12" + resolved "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-29.7.0.tgz" integrity sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g== dependencies: chalk "^4.0.0" @@ -2297,7 +2325,7 @@ jest-matcher-utils@^29.7.0: jest-message-util@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-29.7.0.tgz#8bc392e204e95dfe7564abbe72a404e28e51f7f3" + resolved "https://registry.npmjs.org/jest-message-util/-/jest-message-util-29.7.0.tgz" integrity sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w== dependencies: "@babel/code-frame" "^7.12.13" @@ -2312,7 +2340,7 @@ jest-message-util@^29.7.0: jest-mock@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-mock/-/jest-mock-29.7.0.tgz#4e836cf60e99c6fcfabe9f99d017f3fdd50a6347" + resolved "https://registry.npmjs.org/jest-mock/-/jest-mock-29.7.0.tgz" integrity sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw== dependencies: "@jest/types" "^29.6.3" @@ -2321,17 +2349,17 @@ jest-mock@^29.7.0: jest-pnp-resolver@^1.2.2: version "1.2.3" - resolved "https://registry.yarnpkg.com/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz#930b1546164d4ad5937d5540e711d4d38d4cad2e" + resolved "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz" integrity sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w== jest-regex-util@^29.6.3: version "29.6.3" - resolved "https://registry.yarnpkg.com/jest-regex-util/-/jest-regex-util-29.6.3.tgz#4a556d9c776af68e1c5f48194f4d0327d24e8a52" + resolved "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-29.6.3.tgz" integrity sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg== jest-resolve-dependencies@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-resolve-dependencies/-/jest-resolve-dependencies-29.7.0.tgz#1b04f2c095f37fc776ff40803dc92921b1e88428" + resolved "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-29.7.0.tgz" integrity sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA== dependencies: jest-regex-util "^29.6.3" @@ -2339,7 +2367,7 @@ jest-resolve-dependencies@^29.7.0: jest-resolve@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-resolve/-/jest-resolve-29.7.0.tgz#64d6a8992dd26f635ab0c01e5eef4399c6bcbc30" + resolved "https://registry.npmjs.org/jest-resolve/-/jest-resolve-29.7.0.tgz" integrity sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA== dependencies: chalk "^4.0.0" @@ -2354,7 +2382,7 @@ jest-resolve@^29.7.0: jest-runner@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-runner/-/jest-runner-29.7.0.tgz#809af072d408a53dcfd2e849a4c976d3132f718e" + resolved "https://registry.npmjs.org/jest-runner/-/jest-runner-29.7.0.tgz" integrity sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ== dependencies: "@jest/console" "^29.7.0" @@ -2381,7 +2409,7 @@ jest-runner@^29.7.0: jest-runtime@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-runtime/-/jest-runtime-29.7.0.tgz#efecb3141cf7d3767a3a0cc8f7c9990587d3d817" + resolved "https://registry.npmjs.org/jest-runtime/-/jest-runtime-29.7.0.tgz" integrity sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ== dependencies: "@jest/environment" "^29.7.0" @@ -2409,7 +2437,7 @@ jest-runtime@^29.7.0: jest-snapshot@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-snapshot/-/jest-snapshot-29.7.0.tgz#c2c574c3f51865da1bb329036778a69bf88a6be5" + resolved "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-29.7.0.tgz" integrity sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw== dependencies: "@babel/core" "^7.11.6" @@ -2435,7 +2463,7 @@ jest-snapshot@^29.7.0: jest-util@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-29.7.0.tgz#23c2b62bfb22be82b44de98055802ff3710fc0bc" + resolved "https://registry.npmjs.org/jest-util/-/jest-util-29.7.0.tgz" integrity sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA== dependencies: "@jest/types" "^29.6.3" @@ -2447,7 +2475,7 @@ jest-util@^29.7.0: jest-validate@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-validate/-/jest-validate-29.7.0.tgz#7bf705511c64da591d46b15fce41400d52147d9c" + resolved "https://registry.npmjs.org/jest-validate/-/jest-validate-29.7.0.tgz" integrity sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw== dependencies: "@jest/types" "^29.6.3" @@ -2459,7 +2487,7 @@ jest-validate@^29.7.0: jest-watcher@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-watcher/-/jest-watcher-29.7.0.tgz#7810d30d619c3a62093223ce6bb359ca1b28a2f2" + resolved "https://registry.npmjs.org/jest-watcher/-/jest-watcher-29.7.0.tgz" integrity sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g== dependencies: "@jest/test-result" "^29.7.0" @@ -2473,7 +2501,7 @@ jest-watcher@^29.7.0: jest-worker@^27.4.5: version "27.5.1" - resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.5.1.tgz#8d146f0900e8973b106b6f73cc1e9a8cb86f8db0" + resolved "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz" integrity sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg== dependencies: "@types/node" "*" @@ -2482,7 +2510,7 @@ jest-worker@^27.4.5: jest-worker@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-29.7.0.tgz#acad073acbbaeb7262bd5389e1bcf43e10058d4a" + resolved "https://registry.npmjs.org/jest-worker/-/jest-worker-29.7.0.tgz" integrity sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw== dependencies: "@types/node" "*" @@ -2492,7 +2520,7 @@ jest-worker@^29.7.0: jest@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/jest/-/jest-29.7.0.tgz#994676fc24177f088f1c5e3737f5697204ff2613" + resolved "https://registry.npmjs.org/jest/-/jest-29.7.0.tgz" integrity sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw== dependencies: "@jest/core" "^29.7.0" @@ -2502,20 +2530,20 @@ jest@^29.7.0: js-tokens@^4.0.0: version "4.0.0" - resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" + resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz" integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== js-yaml@^3.13.1: - version "3.14.2" - resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.2.tgz#77485ce1dd7f33c061fd1b16ecea23b55fcb04b0" - integrity sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg== + version "3.14.1" + resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz" + integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== dependencies: argparse "^1.0.7" esprima "^4.0.0" jsdom@^20.0.0: version "20.0.3" - resolved "https://registry.yarnpkg.com/jsdom/-/jsdom-20.0.3.tgz#886a41ba1d4726f67a8858028c99489fed6ad4db" + resolved "https://registry.npmjs.org/jsdom/-/jsdom-20.0.3.tgz" integrity sha512-SYhBvTh89tTfCD/CRdSOm13mOBa42iTaTyfyEWBdKcGdPxPtLFBXuHR8XHb33YNYaP+lLbmSvBTsnoesCNJEsQ== dependencies: abab "^2.0.6" @@ -2547,37 +2575,37 @@ jsdom@^20.0.0: jsesc@^3.0.2: version "3.1.0" - resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-3.1.0.tgz#74d335a234f67ed19907fdadfac7ccf9d409825d" + resolved "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz" integrity sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA== json-parse-even-better-errors@^2.3.0, json-parse-even-better-errors@^2.3.1: version "2.3.1" - resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d" + resolved "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz" integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w== json-schema-traverse@^1.0.0: version "1.0.0" - resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2" + resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz" integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug== json5@^2.2.3: version "2.2.3" - resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283" + resolved "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz" integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg== kleur@^3.0.3: version "3.0.3" - resolved "https://registry.yarnpkg.com/kleur/-/kleur-3.0.3.tgz#a79c9ecc86ee1ce3fa6206d1216c501f147fc07e" + resolved "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz" integrity sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w== leven@^3.1.0: version "3.1.0" - resolved "https://registry.yarnpkg.com/leven/-/leven-3.1.0.tgz#77891de834064cccba82ae7842bb6b14a13ed7f2" + resolved "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz" integrity sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A== lines-and-columns@^1.1.6: version "1.2.4" - resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632" + resolved "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz" integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg== loader-runner@^4.3.1: @@ -2587,55 +2615,55 @@ loader-runner@^4.3.1: locate-path@^5.0.0: version "5.0.0" - resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0" + resolved "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz" integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g== dependencies: p-locate "^4.1.0" lodash.memoize@^4.1.2: version "4.1.2" - resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe" + resolved "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz" integrity sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag== lru-cache@^5.1.1: version "5.1.1" - resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920" + resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz" integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w== dependencies: yallist "^3.0.2" make-dir@^4.0.0: version "4.0.0" - resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-4.0.0.tgz#c3c2307a771277cd9638305f915c29ae741b614e" + resolved "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz" integrity sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw== dependencies: semver "^7.5.3" make-error@^1.3.6: version "1.3.6" - resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2" + resolved "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz" integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== makeerror@1.0.12: version "1.0.12" - resolved "https://registry.yarnpkg.com/makeerror/-/makeerror-1.0.12.tgz#3e5dd2079a82e812e983cc6610c4a2cb0eaa801a" + resolved "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz" integrity sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg== dependencies: tmpl "1.0.5" math-intrinsics@^1.1.0: version "1.1.0" - resolved "https://registry.yarnpkg.com/math-intrinsics/-/math-intrinsics-1.1.0.tgz#a0dd74be81e2aa5c2f27e65ce283605ee4e2b7f9" + resolved "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz" integrity sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g== merge-stream@^2.0.0: version "2.0.0" - resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60" + resolved "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz" integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w== micromatch@^4.0.0, micromatch@^4.0.4: version "4.0.8" - resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.8.tgz#d66fa18f3a47076789320b9b1af32bd86d9fa202" + resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz" integrity sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA== dependencies: braces "^3.0.3" @@ -2643,36 +2671,38 @@ micromatch@^4.0.0, micromatch@^4.0.4: mime-db@1.52.0: version "1.52.0" - resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70" + resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz" integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== mime-types@^2.1.12, mime-types@^2.1.27: version "2.1.35" - resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a" + resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz" integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== dependencies: mime-db "1.52.0" mimic-fn@^2.1.0: version "2.1.0" - resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b" + resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz" integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== minimatch@^3.0.4, minimatch@^3.1.1: version "3.1.2" - resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b" + resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz" integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== dependencies: brace-expansion "^1.1.7" -minimist@^1.2.5: - version "1.2.8" - resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" - integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== +minimatch@^5.0.1: + version "5.1.6" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-5.1.6.tgz#1cfcb8cf5522ea69952cd2af95ae09477f122a96" + integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g== + dependencies: + brace-expansion "^2.0.1" ms@^2.1.3: version "2.1.3" - resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" + resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz" integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== msw@2.11.2: @@ -2707,24 +2737,24 @@ mute-stream@^2.0.0: natural-compare@^1.4.0: version "1.4.0" - resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7" + resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz" integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== neo-async@^2.6.2: version "2.6.2" - resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f" + resolved "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz" integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw== node-fetch@^2.7.0: version "2.7.0" - resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.7.0.tgz#d0f0fa6e3e2dc1d27efcd8ad99d550bda94d187d" + resolved "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz" integrity sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A== dependencies: whatwg-url "^5.0.0" node-int64@^0.4.0: version "0.4.0" - resolved "https://registry.yarnpkg.com/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b" + resolved "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz" integrity sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw== node-releases@^2.0.27: @@ -2734,12 +2764,12 @@ node-releases@^2.0.27: normalize-path@^3.0.0: version "3.0.0" - resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65" + resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz" integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== npm-run-path@^4.0.1: version "4.0.1" - resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea" + resolved "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz" integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw== dependencies: path-key "^3.0.0" @@ -2751,14 +2781,14 @@ nwsapi@^2.2.2: once@^1.3.0: version "1.4.0" - resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" + resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz" integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== dependencies: wrappy "1" onetime@^5.1.2: version "5.1.2" - resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e" + resolved "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz" integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg== dependencies: mimic-fn "^2.1.0" @@ -2770,33 +2800,33 @@ outvariant@^1.4.0, outvariant@^1.4.3: p-limit@^2.2.0: version "2.3.0" - resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1" + resolved "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz" integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w== dependencies: p-try "^2.0.0" p-limit@^3.1.0: version "3.1.0" - resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b" + resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz" integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ== dependencies: yocto-queue "^0.1.0" p-locate@^4.1.0: version "4.1.0" - resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07" + resolved "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz" integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A== dependencies: p-limit "^2.2.0" p-try@^2.0.0: version "2.2.0" - resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6" + resolved "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz" integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ== parse-json@^5.2.0: version "5.2.0" - resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd" + resolved "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz" integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg== dependencies: "@babel/code-frame" "^7.0.0" @@ -2806,29 +2836,29 @@ parse-json@^5.2.0: parse5@^7.0.0, parse5@^7.1.1: version "7.3.0" - resolved "https://registry.yarnpkg.com/parse5/-/parse5-7.3.0.tgz#d7e224fa72399c7a175099f45fc2ad024b05ec05" + resolved "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz" integrity sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw== dependencies: entities "^6.0.0" path-exists@^4.0.0: version "4.0.0" - resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3" + resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz" integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== path-is-absolute@^1.0.0: version "1.0.1" - resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" + resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz" integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== path-key@^3.0.0, path-key@^3.1.0: version "3.1.1" - resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375" + resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz" integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== path-parse@^1.0.7: version "1.0.7" - resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735" + resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz" integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== path-to-regexp@^6.3.0: @@ -2838,29 +2868,29 @@ path-to-regexp@^6.3.0: picocolors@^1.1.1: version "1.1.1" - resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.1.1.tgz#3d321af3eab939b083c8f929a1d12cda81c26b6b" + resolved "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz" integrity sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA== picomatch@^2.0.4, picomatch@^2.2.3, picomatch@^2.3.1: version "2.3.1" - resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42" + resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz" integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== pirates@^4.0.4: version "4.0.7" - resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.7.tgz#643b4a18c4257c8a65104b73f3049ce9a0a15e22" + resolved "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz" integrity sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA== pkg-dir@^4.2.0: version "4.2.0" - resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3" + resolved "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz" integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ== dependencies: find-up "^4.0.0" pretty-format@^29.0.0, pretty-format@^29.7.0: version "29.7.0" - resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-29.7.0.tgz#ca42c758310f365bfa71a0bda0a807160b776812" + resolved "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz" integrity sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ== dependencies: "@jest/schemas" "^29.6.3" @@ -2869,12 +2899,12 @@ pretty-format@^29.0.0, pretty-format@^29.7.0: process@^0.11.10: version "0.11.10" - resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182" + resolved "https://registry.npmjs.org/process/-/process-0.11.10.tgz" integrity sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A== prompts@^2.0.1: version "2.4.2" - resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.4.2.tgz#7b57e73b3a48029ad10ebd44f74b01722a4cb069" + resolved "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz" integrity sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q== dependencies: kleur "^3.0.3" @@ -2882,41 +2912,41 @@ prompts@^2.0.1: psl@^1.1.33: version "1.15.0" - resolved "https://registry.yarnpkg.com/psl/-/psl-1.15.0.tgz#bdace31896f1d97cec6a79e8224898ce93d974c6" + resolved "https://registry.npmjs.org/psl/-/psl-1.15.0.tgz" integrity sha512-JZd3gMVBAVQkSs6HdNZo9Sdo0LNcQeMNP3CozBJb3JYC/QUYZTnKxP+f8oWRX4rHP5EurWxqAHTSwUCjlNKa1w== dependencies: punycode "^2.3.1" punycode@^2.1.1, punycode@^2.3.1: version "2.3.1" - resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5" + resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz" integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg== pure-rand@^6.0.0: version "6.1.0" - resolved "https://registry.yarnpkg.com/pure-rand/-/pure-rand-6.1.0.tgz#d173cf23258231976ccbdb05247c9787957604f2" + resolved "https://registry.npmjs.org/pure-rand/-/pure-rand-6.1.0.tgz" integrity sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA== querystringify@^2.1.1: version "2.2.0" - resolved "https://registry.yarnpkg.com/querystringify/-/querystringify-2.2.0.tgz#3345941b4153cb9d082d8eee4cda2016a9aef7f6" + resolved "https://registry.npmjs.org/querystringify/-/querystringify-2.2.0.tgz" integrity sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ== randombytes@^2.1.0: version "2.1.0" - resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a" + resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz" integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ== dependencies: safe-buffer "^5.1.0" react-is@^18.0.0: version "18.3.1" - resolved "https://registry.yarnpkg.com/react-is/-/react-is-18.3.1.tgz#e83557dc12eae63a99e003a46388b1dcbb44db7e" + resolved "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz" integrity sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg== readable-stream@^4.5.2: version "4.7.0" - resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-4.7.0.tgz#cedbd8a1146c13dfff8dab14068028d58c15ac91" + resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-4.7.0.tgz" integrity sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg== dependencies: abort-controller "^3.0.0" @@ -2927,34 +2957,34 @@ readable-stream@^4.5.2: require-directory@^2.1.1: version "2.1.1" - resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42" + resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz" integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== require-from-string@^2.0.2: version "2.0.2" - resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909" + resolved "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz" integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw== requires-port@^1.0.0: version "1.0.0" - resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff" + resolved "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz" integrity sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ== resolve-cwd@^3.0.0: version "3.0.0" - resolved "https://registry.yarnpkg.com/resolve-cwd/-/resolve-cwd-3.0.0.tgz#0f0075f1bb2544766cf73ba6a6e2adfebcb13f2d" + resolved "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz" integrity sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg== dependencies: resolve-from "^5.0.0" resolve-from@^5.0.0: version "5.0.0" - resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69" + resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz" integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw== resolve.exports@^2.0.0: version "2.0.3" - resolved "https://registry.yarnpkg.com/resolve.exports/-/resolve.exports-2.0.3.tgz#41955e6f1b4013b7586f873749a635dea07ebe3f" + resolved "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.3.tgz" integrity sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A== resolve@^1.20.0: @@ -2973,17 +3003,17 @@ rettime@^0.7.0: safe-buffer@^5.1.0, safe-buffer@~5.2.0: version "5.2.1" - resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6" + resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz" integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== "safer-buffer@>= 2.1.2 < 3.0.0": version "2.1.2" - resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a" + resolved "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz" integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg== saxes@^6.0.0: version "6.0.0" - resolved "https://registry.yarnpkg.com/saxes/-/saxes-6.0.0.tgz#fe5b4a4768df4f14a201b1ba6a65c1f3d9988cc5" + resolved "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz" integrity sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA== dependencies: xmlchars "^2.2.0" @@ -3000,36 +3030,36 @@ schema-utils@^4.3.0, schema-utils@^4.3.3: semver@^6.3.0, semver@^6.3.1: version "6.3.1" - resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4" + resolved "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz" integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA== -semver@^7.3.4, semver@^7.5.3, semver@^7.5.4, semver@^7.7.3: +semver@^7.3.4, semver@^7.5.3, semver@^7.5.4, semver@^7.7.2: version "7.7.3" resolved "https://registry.yarnpkg.com/semver/-/semver-7.7.3.tgz#4b5f4143d007633a8dc671cd0a6ef9147b8bb946" integrity sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q== serialize-javascript@^6.0.2: version "6.0.2" - resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-6.0.2.tgz#defa1e055c83bf6d59ea805d8da862254eb6a6c2" + resolved "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz" integrity sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g== dependencies: randombytes "^2.1.0" shebang-command@^2.0.0: version "2.0.0" - resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea" + resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz" integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== dependencies: shebang-regex "^3.0.0" shebang-regex@^3.0.0: version "3.0.0" - resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172" + resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz" integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== signal-exit@^3.0.3, signal-exit@^3.0.7: version "3.0.7" - resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9" + resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz" integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ== signal-exit@^4.1.0: @@ -3039,17 +3069,17 @@ signal-exit@^4.1.0: sisteransi@^1.0.5: version "1.0.5" - resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed" + resolved "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz" integrity sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg== slash@^3.0.0: version "3.0.0" - resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634" + resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz" integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q== source-map-support@0.5.13: version "0.5.13" - resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.13.tgz#31b24a9c2e73c2de85066c0feb7d44767ed52932" + resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.13.tgz" integrity sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w== dependencies: buffer-from "^1.0.0" @@ -3057,7 +3087,7 @@ source-map-support@0.5.13: source-map-support@~0.5.20: version "0.5.21" - resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f" + resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz" integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w== dependencies: buffer-from "^1.0.0" @@ -3065,22 +3095,22 @@ source-map-support@~0.5.20: source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1: version "0.6.1" - resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" + resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz" integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== source-map@^0.7.4: version "0.7.6" - resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.6.tgz#a3658ab87e5b6429c8a1f3ba0083d4c61ca3ef02" + resolved "https://registry.npmjs.org/source-map/-/source-map-0.7.6.tgz" integrity sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ== sprintf-js@~1.0.2: version "1.0.3" - resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c" + resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz" integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g== stack-utils@^2.0.3: version "2.0.6" - resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-2.0.6.tgz#aaf0748169c02fc33c8232abccf933f54a1cc34f" + resolved "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz" integrity sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ== dependencies: escape-string-regexp "^2.0.0" @@ -3097,7 +3127,7 @@ strict-event-emitter@^0.5.1: string-length@^4.0.1: version "4.0.2" - resolved "https://registry.yarnpkg.com/string-length/-/string-length-4.0.2.tgz#a8a8dc7bd5c1a82b9b3c8b87e125f66871b6e57a" + resolved "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz" integrity sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ== dependencies: char-regex "^1.0.2" @@ -3105,7 +3135,7 @@ string-length@^4.0.1: string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: version "4.2.3" - resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" + resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz" integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== dependencies: emoji-regex "^8.0.0" @@ -3114,55 +3144,55 @@ string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: string_decoder@^1.3.0: version "1.3.0" - resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e" + resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz" integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA== dependencies: safe-buffer "~5.2.0" strip-ansi@^6.0.0, strip-ansi@^6.0.1: version "6.0.1" - resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" + resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz" integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== dependencies: ansi-regex "^5.0.1" strip-bom@^4.0.0: version "4.0.0" - resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878" + resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz" integrity sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w== strip-final-newline@^2.0.0: version "2.0.0" - resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad" + resolved "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz" integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA== strip-json-comments@^3.1.1: version "3.1.1" - resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006" + resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz" integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== supports-color@^7.1.0: version "7.2.0" - resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz" integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== dependencies: has-flag "^4.0.0" supports-color@^8.0.0: version "8.1.1" - resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz" integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q== dependencies: has-flag "^4.0.0" supports-preserve-symlinks-flag@^1.0.0: version "1.0.0" - resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09" + resolved "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz" integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== symbol-tree@^3.2.4: version "3.2.4" - resolved "https://registry.yarnpkg.com/symbol-tree/-/symbol-tree-3.2.4.tgz#430637d248ba77e078883951fb9aa0eed7c63fa2" + resolved "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz" integrity sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw== tapable@^2.2.0, tapable@^2.3.0: @@ -3193,7 +3223,7 @@ terser@^5.31.1: test-exclude@^6.0.0: version "6.0.0" - resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-6.0.0.tgz#04a8698661d805ea6fa293b6cb9e63ac044ef15e" + resolved "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz" integrity sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w== dependencies: "@istanbuljs/schema" "^0.1.2" @@ -3214,19 +3244,19 @@ tldts@^7.0.5: tmpl@1.0.5: version "1.0.5" - resolved "https://registry.yarnpkg.com/tmpl/-/tmpl-1.0.5.tgz#8683e0b902bb9c20c4f726e3c0b69f36518c07cc" + resolved "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz" integrity sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw== to-regex-range@^5.0.1: version "5.0.1" - resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4" + resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz" integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== dependencies: is-number "^7.0.0" tough-cookie@^4.1.2: version "4.1.4" - resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-4.1.4.tgz#945f1461b45b5a8c76821c33ea49c3ac192c1b36" + resolved "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.1.4.tgz" integrity sha512-Loo5UUvLD9ScZ6jh8beX1T6sO1w2/MpCRpEP7V280GKMVUQ0Jzar2U3UJPsrdbziLEMMhu3Ujnq//rhiFuIeag== dependencies: psl "^1.1.33" @@ -3243,14 +3273,14 @@ tough-cookie@^6.0.0: tr46@^3.0.0: version "3.0.0" - resolved "https://registry.yarnpkg.com/tr46/-/tr46-3.0.0.tgz#555c4e297a950617e8eeddef633c87d4d9d6cbf9" + resolved "https://registry.npmjs.org/tr46/-/tr46-3.0.0.tgz" integrity sha512-l7FvfAHlcmulp8kr+flpQZmVwtu7nfRV7NZujtN0OqES8EL4O4e0qqzL0DC5gAvx/ZC/9lk6rhcUwYvkBnBnYA== dependencies: punycode "^2.1.1" tr46@~0.0.3: version "0.0.3" - resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a" + resolved "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz" integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw== ts-jest@^29.3.4: @@ -3281,32 +3311,27 @@ ts-loader@^9.5.1: type-detect@4.0.8: version "4.0.8" - resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c" + resolved "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz" integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g== type-fest@^0.21.3: version "0.21.3" - resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz" integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w== type-fest@^4.26.1, type-fest@^4.41.0: version "4.41.0" - resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-4.41.0.tgz#6ae1c8e5731273c2bf1f58ad39cbae2c91a46c58" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz" integrity sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA== typescript@~5.7.2: version "5.7.3" - resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.7.3.tgz#919b44a7dbb8583a9b856d162be24a54bf80073e" + resolved "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz" integrity sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw== -uglify-js@^3.1.4: - version "3.19.3" - resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.19.3.tgz#82315e9bbc6f2b25888858acd1fff8441035b77f" - integrity sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ== - undici-types@~5.26.4: version "5.26.5" - resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617" + resolved "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz" integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA== undici-types@~7.16.0: @@ -3316,7 +3341,7 @@ undici-types@~7.16.0: universalify@^0.2.0: version "0.2.0" - resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.2.0.tgz#6451760566fa857534745ab1dde952d1b1761be0" + resolved "https://registry.npmjs.org/universalify/-/universalify-0.2.0.tgz" integrity sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg== update-browserslist-db@^1.2.0: @@ -3329,7 +3354,7 @@ update-browserslist-db@^1.2.0: url-parse@^1.5.3: version "1.5.10" - resolved "https://registry.yarnpkg.com/url-parse/-/url-parse-1.5.10.tgz#9d3c2f736c1d75dd3bd2be507dcc111f1e2ea9c1" + resolved "https://registry.npmjs.org/url-parse/-/url-parse-1.5.10.tgz" integrity sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ== dependencies: querystringify "^2.1.1" @@ -3337,7 +3362,7 @@ url-parse@^1.5.3: v8-to-istanbul@^9.0.1: version "9.3.0" - resolved "https://registry.yarnpkg.com/v8-to-istanbul/-/v8-to-istanbul-9.3.0.tgz#b9572abfa62bd556c16d75fdebc1a411d5ff3175" + resolved "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.3.0.tgz" integrity sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA== dependencies: "@jridgewell/trace-mapping" "^0.3.12" @@ -3346,39 +3371,39 @@ v8-to-istanbul@^9.0.1: w3c-xmlserializer@^4.0.0: version "4.0.0" - resolved "https://registry.yarnpkg.com/w3c-xmlserializer/-/w3c-xmlserializer-4.0.0.tgz#aebdc84920d806222936e3cdce408e32488a3073" + resolved "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-4.0.0.tgz" integrity sha512-d+BFHzbiCx6zGfz0HyQ6Rg69w9k19nviJspaj4yNscGjrHu94sVP+aRm75yEbCh+r2/yR+7q6hux9LVtbuTGBw== dependencies: xml-name-validator "^4.0.0" walker@^1.0.8: version "1.0.8" - resolved "https://registry.yarnpkg.com/walker/-/walker-1.0.8.tgz#bd498db477afe573dc04185f011d3ab8a8d7653f" + resolved "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz" integrity sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ== dependencies: makeerror "1.0.12" watchpack@^2.4.4: - version "2.4.4" - resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-2.4.4.tgz#473bda72f0850453da6425081ea46fc0d7602947" - integrity sha512-c5EGNOiyxxV5qmTtAB7rbiXxi1ooX1pQKMLX/MIabJjRA0SJBQOjKF+KSVfHkr9U1cADPon0mRiVe/riyaiDUA== + version "2.5.0" + resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-2.5.0.tgz#fa115d5ccaa4bf3aa594f586257c0bc4768939fd" + integrity sha512-e6vZvY6xboSwLz2GD36c16+O/2Z6fKvIf4pOXptw2rY9MVwE/TXc6RGqxD3I3x0a28lwBY7DE+76uTPSsBrrCA== dependencies: glob-to-regexp "^0.4.1" graceful-fs "^4.1.2" webidl-conversions@^3.0.0: version "3.0.1" - resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871" + resolved "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz" integrity sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ== webidl-conversions@^7.0.0: version "7.0.0" - resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-7.0.0.tgz#256b4e1882be7debbf01d05f0aa2039778ea080a" + resolved "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz" integrity sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g== webpack-sources@^3.3.3: version "3.3.3" - resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-3.3.3.tgz#d4bf7f9909675d7a070ff14d0ef2a4f3c982c723" + resolved "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.3.3.tgz" integrity sha512-yd1RBzSGanHkitROoPFd6qsrxt+oFhg/129YzheDGqeustzX0vTZJZsSsQjVQC4yzBQ56K55XU8gaNCtIzOnTg== webpack@^5.97.1: @@ -3414,19 +3439,19 @@ webpack@^5.97.1: whatwg-encoding@^2.0.0: version "2.0.0" - resolved "https://registry.yarnpkg.com/whatwg-encoding/-/whatwg-encoding-2.0.0.tgz#e7635f597fd87020858626805a2729fa7698ac53" + resolved "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-2.0.0.tgz" integrity sha512-p41ogyeMUrw3jWclHWTQg1k05DSVXPLcVxRTYsXUk+ZooOCZLcoYgPZ/HL/D/N+uQPOtcp1me1WhBEaX02mhWg== dependencies: iconv-lite "0.6.3" whatwg-mimetype@^3.0.0: version "3.0.0" - resolved "https://registry.yarnpkg.com/whatwg-mimetype/-/whatwg-mimetype-3.0.0.tgz#5fa1a7623867ff1af6ca3dc72ad6b8a4208beba7" + resolved "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-3.0.0.tgz" integrity sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q== whatwg-url@^11.0.0: version "11.0.0" - resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-11.0.0.tgz#0a849eebb5faf2119b901bb76fd795c2848d4018" + resolved "https://registry.npmjs.org/whatwg-url/-/whatwg-url-11.0.0.tgz" integrity sha512-RKT8HExMpoYx4igMiVMY83lN6UeITKJlBQ+vR/8ZJ8OCdSiN3RwCq+9gH0+Xzj0+5IrM6i4j/6LuvzbZIQgEcQ== dependencies: tr46 "^3.0.0" @@ -3434,7 +3459,7 @@ whatwg-url@^11.0.0: whatwg-url@^5.0.0: version "5.0.0" - resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d" + resolved "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz" integrity sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw== dependencies: tr46 "~0.0.3" @@ -3442,16 +3467,11 @@ whatwg-url@^5.0.0: which@^2.0.1: version "2.0.2" - resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1" + resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz" integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== dependencies: isexe "^2.0.0" -wordwrap@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb" - integrity sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q== - wrap-ansi@^6.2.0: version "6.2.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53" @@ -3463,7 +3483,7 @@ wrap-ansi@^6.2.0: wrap-ansi@^7.0.0: version "7.0.0" - resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" + resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz" integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== dependencies: ansi-styles "^4.0.0" @@ -3472,12 +3492,12 @@ wrap-ansi@^7.0.0: wrappy@1: version "1.0.2" - resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" + resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz" integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== write-file-atomic@^4.0.2: version "4.0.2" - resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-4.0.2.tgz#a9df01ae5b77858a027fd2e80768ee433555fcfd" + resolved "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-4.0.2.tgz" integrity sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg== dependencies: imurmurhash "^0.1.4" @@ -3485,37 +3505,37 @@ write-file-atomic@^4.0.2: ws@^8.11.0: version "8.18.3" - resolved "https://registry.yarnpkg.com/ws/-/ws-8.18.3.tgz#b56b88abffde62791c639170400c93dcb0c95472" + resolved "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz" integrity sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg== xml-name-validator@^4.0.0: version "4.0.0" - resolved "https://registry.yarnpkg.com/xml-name-validator/-/xml-name-validator-4.0.0.tgz#79a006e2e63149a8600f15430f0a4725d1524835" + resolved "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-4.0.0.tgz" integrity sha512-ICP2e+jsHvAj2E2lIHxa5tjXRlKDJo4IdvPvCXbXQGdzSfmSpNVyIKMvoZHjDY9DP0zV17iI85o90vRFXNccRw== xmlchars@^2.2.0: version "2.2.0" - resolved "https://registry.yarnpkg.com/xmlchars/-/xmlchars-2.2.0.tgz#060fe1bcb7f9c76fe2a17db86a9bc3ab894210cb" + resolved "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz" integrity sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw== y18n@^5.0.5: version "5.0.8" - resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55" + resolved "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz" integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== yallist@^3.0.2: version "3.1.1" - resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd" + resolved "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz" integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g== yargs-parser@^21.1.1: version "21.1.1" - resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35" + resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz" integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw== yargs@^17.3.1, yargs@^17.7.2: version "17.7.2" - resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269" + resolved "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz" integrity sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w== dependencies: cliui "^8.0.1" @@ -3528,7 +3548,7 @@ yargs@^17.3.1, yargs@^17.7.2: yocto-queue@^0.1.0: version "0.1.0" - resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b" + resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz" integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== yoctocolors-cjs@^2.1.3: