From 4726a2fc5a520a3d19969c6c35392e6da4336e35 Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Fri, 25 Jul 2025 15:10:42 -0400 Subject: [PATCH 01/31] docs: add cloudflare worker implementation plan for mcp sse --- src/mcp/cloudflare-worker-plan.md | 576 ++++++++++++++++++++++++++++++ 1 file changed, 576 insertions(+) create mode 100644 src/mcp/cloudflare-worker-plan.md diff --git a/src/mcp/cloudflare-worker-plan.md b/src/mcp/cloudflare-worker-plan.md new file mode 100644 index 000000000..4a6b3c922 --- /dev/null +++ b/src/mcp/cloudflare-worker-plan.md @@ -0,0 +1,576 @@ +# DevCycle MCP Cloudflare Worker Implementation Plan + +## Overview + +This document outlines the plan to create a Cloudflare Worker-based MCP server that hosts the DevCycle CLI's MCP tools, following the architecture of the `mcp.devcycle.com` example. The server will support both local installation and remote access via SSE (Server-Sent Events). + +## Architecture Overview + +### Key Components + +1. **Cloudflare Worker MCP Server** - Remote server hosting all MCP tools +2. **OAuth Provider Integration** - Using `@cloudflare/workers-oauth-provider` for authentication +3. **SSE Transport** - Server-Sent Events for MCP communication +4. **Durable Objects** - For maintaining MCP session state +5. **Dual Access Mode** - Tools accessible both locally and remotely + +### Architecture Diagram + +``` +┌─────────────────────────────────────────────────────────────────────┐ +│ Claude Desktop / AI Client │ +├─────────────────────────────────────────────────────────────────────┤ +│ mcp-remote proxy │ +└───────────────────────┬─────────────────────────┬───────────────────┘ + │ │ + │ SSE Connection │ Local Installation + │ │ +┌───────────────────────▼────────────┐ ┌───────▼───────────────────┐ +│ Cloudflare Worker MCP Server │ │ Local MCP Server (stdio) │ +│ │ │ │ +│ ┌─────────────────────────────┐ │ │ ┌────────────────────┐ │ +│ │ OAuth Authentication │ │ │ │ Local Auth │ │ +│ │ (Auth0/DevCycle SSO) │ │ │ │ (CLI Config) │ │ +│ └─────────────────────────────┘ │ │ └────────────────────┘ │ +│ │ │ │ +│ ┌─────────────────────────────┐ │ │ ┌────────────────────┐ │ +│ │ MCP Tool Registry │ │ │ │ MCP Tool Registry │ │ +│ │ (Features, Variables, etc) │ │ │ │ (Same Tools) │ │ +│ └─────────────────────────────┘ │ │ └────────────────────┘ │ +│ │ │ │ +│ ┌─────────────────────────────┐ │ │ ┌────────────────────┐ │ +│ │ DevCycle API Client │ │ │ │ DevCycle API Client│ │ +│ │ (HTTP with Auth Token) │ │ │ │ (HTTP with Keys) │ │ +│ └─────────────────────────────┘ │ │ └────────────────────┘ │ +└────────────────────────────────────┘ └───────────────────────────┘ + │ │ + └─────────────┬───────────┘ + │ + ┌────────────▼────────────┐ + │ DevCycle API │ + │ (api.devcycle.com) │ + └─────────────────────────┘ +``` + +## Implementation Structure + +### Directory Structure + +``` +cli/ +├── src/ +│ └── mcp/ +│ ├── index.ts # Existing local MCP server (stdio) +│ ├── server.ts # Existing MCP server class +│ ├── tools/ # Existing tool implementations +│ └── worker/ # NEW: Cloudflare Worker implementation +│ ├── index.ts # Worker entry point +│ ├── auth.ts # OAuth authentication +│ ├── mcp-server.ts # Worker MCP server class +│ ├── api-client.ts # Worker-specific API client +│ └── types.ts # Worker-specific types +├── mcp-worker/ # NEW: Separate package for CF Worker +│ ├── package.json +│ ├── wrangler.toml +│ ├── tsconfig.json +│ └── src/ +│ └── index.ts # Re-exports from main package +└── docs/ + └── mcp/ + └── cloudflare-deployment.md # Deployment instructions +``` + +## Phase 1: Refactor for Dual-Mode Support + +### 1.1 Extract Core Tool Logic + +Currently, the MCP tools are tightly coupled to the local server implementation in `src/mcp/server.ts`, making it impossible to reuse them in a Cloudflare Worker environment. By extracting the core tool logic into a registry pattern, we can share the same tool implementations between both the stdio-based local server and the SSE-based Worker server, ensuring consistency and reducing code duplication. + +Create a tool registry that can be used by both local and remote implementations: + +```typescript +// src/mcp/tools/registry.ts +export interface MCPToolDefinition { + name: string; + description: string; + inputSchema: any; + handler: (args: unknown, client: DevCycleApiClient) => Promise; +} + +export class MCPToolRegistry { + private tools = new Map(); + + register(tool: MCPToolDefinition): void { + this.tools.set(tool.name, tool); + } + + getAll(): MCPToolDefinition[] { + return Array.from(this.tools.values()); + } + + execute(name: string, args: unknown, client: DevCycleApiClient): Promise { + const tool = this.tools.get(name); + if (!tool) throw new Error(`Unknown tool: ${name}`); + return tool.handler(args, client); + } +} +``` + +### 1.2 Create Abstracted API Client Interface + +The current `DevCycleApiClient` in `src/mcp/utils/api.ts` depends on the local `DevCycleAuth` class which uses file system operations and environment variables that aren't available in Cloudflare Workers. By creating an interface abstraction, we can implement different authentication strategies: the local client will continue using API keys and config files, while the Worker client will use OAuth tokens from the JWT claims passed through the authentication flow. + +```typescript +// src/mcp/api/interface.ts +export interface IDevCycleApiClient { + executeWithLogging( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise + ): Promise; + + executeWithDashboardLink( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + dashboardLink: (orgId: string, projectKey: string, result: T) => string + ): Promise<{ result: T; dashboardLink: string }>; +} +``` + +### 1.3 Refactor Existing Tools + +Currently, each tool file exports separate handler functions and tool definitions that are directly imported and registered in `server.ts`. This tight coupling prevents the tools from being used in different contexts. By refactoring to use a registration function pattern, tools become portable modules that can be registered with any MCP server implementation, whether it's running locally or in a Cloudflare Worker. + +Update all tool files to use the registry pattern: + +```typescript +// src/mcp/tools/featureTools.ts +export function registerFeatureTools(registry: MCPToolRegistry) { + registry.register({ + name: 'list_features', + description: 'List features in the current project', + inputSchema: { /* ... */ }, + handler: async (args, apiClient) => { + // Existing implementation + } + }); + // ... register other feature tools +} +``` + +## Phase 2: Cloudflare Worker Implementation + +### 2.1 Worker Entry Point + +The Worker entry point needs to integrate multiple systems: the MCP SDK's `McpAgent` for handling the protocol, Cloudflare's OAuth provider for authentication, and Hono for HTTP routing. Unlike the local implementation which uses stdio transport, the Worker uses SSE (Server-Sent Events) to communicate with clients through the `mcp-remote` proxy. The `DevCycleMCP` class extends `McpAgent` with Durable Objects support to maintain session state across requests, which is essential for the stateless Worker environment. + +```typescript +// src/mcp/worker/index.ts +import OAuthProvider, { type OAuthHelpers } from "@cloudflare/workers-oauth-provider"; +import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; +import { McpAgent } from "agents/mcp"; +import { Hono } from "hono"; +import { authorize, callback, confirmConsent, tokenExchangeCallback } from "./auth"; +import { MCPToolRegistry } from "../tools/registry"; +import { WorkerApiClient } from "./api-client"; +import { registerAllTools } from "../tools"; + +export class DevCycleMCP extends McpAgent, UserProps> { + server = new McpServer({ + name: "DevCycle CLI MCP Server", + version: "1.0.0", + }); + + private registry = new MCPToolRegistry(); + private apiClient: WorkerApiClient; + + async init() { + // Initialize the Worker-specific API client with OAuth tokens + this.apiClient = new WorkerApiClient(this.props, this.env); + + // Register all tools from the shared registry - same tools as local implementation + registerAllTools(this.registry); + + // Dynamically create MCP protocol handlers for each registered tool + for (const tool of this.registry.getAll()) { + this.server.tool( + tool.name, + tool.description, + tool.inputSchema, + async (args) => { + try { + // Execute tool with Worker-specific API client that uses OAuth tokens + const result = await this.registry.execute( + tool.name, + args, + this.apiClient + ); + // Format response according to MCP protocol expectations + return { + content: [{ + type: "text", + text: JSON.stringify(result, null, 2) + }] + }; + } catch (error) { + // Standardized error handling across all tools + return { + content: [{ + type: "text", + text: `Error: ${error.message}` + }] + }; + } + } + ); + } + } +} + +// Initialize Hono app with OAuth routes for handling the authentication flow +const app = new Hono<{ Bindings: Env & { OAUTH_PROVIDER: OAuthHelpers } }>(); +app.get("/authorize", authorize); // Initiates OAuth flow with DevCycle +app.post("/authorize/consent", confirmConsent); // Handles user consent +app.get("/callback", callback); // Receives OAuth callback with tokens +app.get("/health", (c) => c.json({ status: "ok" })); // Health check endpoint + +// Configure the OAuth provider with MCP SSE endpoint +export default new OAuthProvider({ + apiHandler: DevCycleMCP.mount("/sse"), // MCP protocol over Server-Sent Events + apiRoute: "/sse", + authorizeEndpoint: "/authorize", + clientRegistrationEndpoint: "/signup", + defaultHandler: app, + tokenEndpoint: "/token", + tokenExchangeCallback, // Converts OAuth tokens to UserProps +}); +``` + +### 2.2 Worker-Specific API Client + +The Worker API client differs significantly from the local implementation because it receives authentication through OAuth tokens in the JWT claims rather than API keys. The project context, which locally comes from config files or environment variables, must be extracted from either the JWT claims (where it can be embedded during the OAuth flow) or fallback to Worker environment variables. This client implements the same `IDevCycleApiClient` interface but with Worker-specific authentication and configuration strategies, ensuring tool compatibility while adapting to the serverless environment constraints. + +```typescript +// src/mcp/worker/api-client.ts +import type { UserProps } from "./types"; +import { IDevCycleApiClient } from "../api/interface"; + +export class WorkerApiClient implements IDevCycleApiClient { + constructor( + private props: UserProps, + private env: Env + ) {} + + async executeWithLogging( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise + ): Promise { + // Extract project from JWT claims or environment + const projectKey = this.getProjectKey(); + const authToken = this.props.tokenSet.accessToken; + + console.log(`Worker MCP ${operationName}:`, args); + + try { + return await operation(authToken, projectKey); + } catch (error) { + console.error(`Worker MCP ${operationName} error:`, error); + throw error; + } + } + + private getProjectKey(): string { + // Try from JWT claims first - this allows user-specific project context + if (this.props.claims?.project_key) { + return this.props.claims.project_key as string; + } + // Fall back to environment variable for single-project deployments + if (this.env.DEFAULT_PROJECT_KEY) { + return this.env.DEFAULT_PROJECT_KEY; + } + throw new Error("No project key found in claims or environment"); + } + + private getOrgId(): string { + // Extract from JWT claims + if (this.props.claims?.org_id) { + return this.props.claims.org_id as string; + } + throw new Error("No organization ID found in claims"); + } + + async executeWithDashboardLink(/* ... */) { + // Similar implementation with dashboard link generation + } +} +``` + +### 2.3 Authentication Implementation + +The authentication implementation handles the OAuth token exchange callback, which is triggered after users authenticate with DevCycle's Auth0 provider. This function extracts user information from the ID token's JWT claims and packages it into the `UserProps` structure that gets passed to the MCP agent. The TTL (time-to-live) setting ensures that sessions are refreshed periodically, maintaining security while providing a smooth user experience. This approach allows the Worker to operate with the same DevCycle API permissions as the authenticated user, respecting organizational boundaries and access controls. + +```typescript +// src/mcp/worker/auth.ts +import type { TokenExchangeCallbackOptions, TokenExchangeCallbackResult } from "@cloudflare/workers-oauth-provider"; +import * as oauth from "oauth4webapi"; +import type { UserProps } from "./types"; + +export async function tokenExchangeCallback( + options: TokenExchangeCallbackOptions +): Promise> { + const { tokenSet, userInfo } = options; + + // Extract user information from ID token - includes org_id, project_key, permissions + const claims = parseJWT(tokenSet.id_token); + + return { + props: { + claims, // JWT claims contain user context and permissions + tokenSet: { + accessToken: tokenSet.access_token, // Used for DevCycle API calls + idToken: tokenSet.id_token, // Contains user identity + refreshToken: tokenSet.refresh_token || "", // For token renewal + }, + }, + ttl: 3600, // 1 hour - balances security with user experience + }; +} +``` + +## Phase 3: Deployment Configuration + +### 3.1 Wrangler Configuration + +```toml +# mcp-worker/wrangler.toml +name = "devcycle-mcp-server" +main = "src/index.ts" +compatibility_date = "2025-03-10" +compatibility_flags = ["nodejs_compat"] + +[migrations] +new_sqlite_classes = ["DevCycleMCP"] +tag = "v1" + +[durable_objects] +bindings = [ + { class_name = "DevCycleMCP", name = "MCP_OBJECT" } +] + +[kv_namespaces] +binding = "OAUTH_KV" +id = "YOUR_KV_NAMESPACE_ID" + +[vars] +NODE_ENV = "production" +API_BASE_URL = "https://api.devcycle.com" +AUTH0_DOMAIN = "auth.devcycle.com" +AUTH0_AUDIENCE = "https://api.devcycle.com/" +AUTH0_SCOPE = "openid profile email offline_access" +# AUTH0_CLIENT_ID and AUTH0_CLIENT_SECRET should be set as secrets + +[ai] +binding = "AI" + +[observability] +enabled = true +``` + +### 3.2 Package Configuration + +```json +// mcp-worker/package.json +{ + "name": "@devcycle/mcp-worker", + "version": "1.0.0", + "private": true, + "type": "module", + "scripts": { + "dev": "wrangler dev", + "deploy": "wrangler deploy", + "build": "tsc" + }, + "dependencies": { + "@cloudflare/workers-oauth-provider": "^0.0.5", + "@devcycle/cli": "file:../", + "@modelcontextprotocol/sdk": "^1.13.1", + "agents": "^0.0.100", + "hono": "^4.8.4", + "oauth4webapi": "^3.5.5" + } +} +``` + +## Phase 4: Build System Updates + +### 4.1 Shared Code Compilation + +Update the main CLI build to create a separate bundle for shared MCP code: + +```json +// package.json +{ + "scripts": { + "build:mcp-shared": "tsc --project tsconfig.mcp.json", + "build:worker": "cd mcp-worker && npm run build", + "deploy:worker": "cd mcp-worker && npm run deploy" + } +} +``` + +### 4.2 TypeScript Configuration + +```json +// tsconfig.mcp.json +{ + "extends": "./tsconfig.json", + "compilerOptions": { + "outDir": "./dist/mcp-shared", + "declaration": true, + "declarationMap": true + }, + "include": [ + "src/mcp/tools/**/*", + "src/mcp/api/interface.ts", + "src/api/**/*" + ] +} +``` + +## Phase 5: Testing Strategy + +### 5.1 Unit Tests + +- Test tool handlers in isolation +- Mock API client for both local and worker implementations +- Test authentication flows + +### 5.2 Integration Tests + +```typescript +// test/mcp-worker/integration.test.ts +describe('MCP Worker Integration', () => { + let worker: UnstableDevWorker; + + beforeAll(async () => { + worker = await unstable_dev("mcp-worker/src/index.ts", { + experimental: { disableExperimentalWarning: true }, + }); + }); + + afterAll(async () => { + await worker.stop(); + }); + + it('should list features via SSE', async () => { + // Test SSE connection and tool execution + }); +}); +``` + +### 5.3 E2E Tests + +- Deploy to preview environment +- Test with actual Claude Desktop/AI Playground +- Verify OAuth flow + +## Phase 6: Documentation + +### 6.1 Deployment Guide + +```markdown +# Deploying DevCycle MCP Server to Cloudflare + +## Prerequisites +- Cloudflare account +- Wrangler CLI installed +- DevCycle OAuth application credentials + +## Deployment Steps + +1. Clone the repository +2. Install dependencies: `yarn install` +3. Create KV namespace: `wrangler kv:namespace create OAUTH_KV` +4. Set secrets: + ```bash + wrangler secret put AUTH0_CLIENT_ID + wrangler secret put AUTH0_CLIENT_SECRET + ``` +5. Deploy: `yarn deploy:worker` + +## Connecting Clients + +### Claude Desktop +```json +{ + "mcpServers": { + "devcycle": { + "command": "npx", + "args": [ + "mcp-remote", + "https://devcycle-mcp.your-account.workers.dev/sse" + ] + } + } +} +``` + +### Local Development +```bash +# Use local MCP server +dvc mcp + +# Or connect to remote +npx mcp-remote http://localhost:8787/sse +``` +``` + +## Phase 7: Monitoring and Operations + +### 7.1 Logging and Metrics + +- Implement structured logging +- Track tool usage metrics +- Monitor OAuth success rates +- Alert on errors + +### 7.2 Security Considerations + +- Validate all input parameters +- Implement rate limiting +- Secure token storage +- CORS configuration for web clients + +## Phase 8: Future Enhancements + +### 8.1 Advanced Features + +- WebSocket support for real-time updates +- Batch operations for multiple tools +- Caching layer for frequently accessed data +- Multi-tenant support + +### 8.2 Performance Optimizations + +- Edge caching for read operations +- Connection pooling for API calls +- Lazy loading of tool implementations + +## Timeline + +- **Week 1-2**: Phase 1 - Refactor for dual-mode support +- **Week 3-4**: Phase 2 - Cloudflare Worker implementation +- **Week 5**: Phase 3-4 - Deployment and build system +- **Week 6**: Phase 5 - Testing +- **Week 7**: Phase 6-7 - Documentation and monitoring +- **Week 8**: Buffer and refinements + +## Success Criteria + +1. All existing MCP tools work in both local and remote modes +2. OAuth authentication works seamlessly +3. Performance is acceptable (< 500ms latency for most operations) +4. Zero downtime deployment process +5. Comprehensive documentation for users and developers \ No newline at end of file From ce72f15f591e1eee6f3301ce78e7f1fe78fc5c14 Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Fri, 25 Jul 2025 15:38:00 -0400 Subject: [PATCH 02/31] feat: extract core tool logic into registry pattern - Create MCPToolRegistry interface and class for tool management - Add IDevCycleApiClient interface for API abstraction - Refactor project tools to use registry pattern - Add central tool registration coordination - Maintain backward compatibility with legacy exports - Add comprehensive registry tests (7 test cases) This enables sharing tool implementations between local and remote MCP servers while preserving existing functionality. Phase 1.1 of Cloudflare Worker plan. --- src/mcp/tools/index.ts | 49 +++++++++ src/mcp/tools/projectTools.ts | 176 ++++++++++++++++++++++++++++++--- src/mcp/tools/registry.test.ts | 126 +++++++++++++++++++++++ src/mcp/tools/registry.ts | 112 +++++++++++++++++++++ 4 files changed, 452 insertions(+), 11 deletions(-) create mode 100644 src/mcp/tools/index.ts create mode 100644 src/mcp/tools/registry.test.ts create mode 100644 src/mcp/tools/registry.ts diff --git a/src/mcp/tools/index.ts b/src/mcp/tools/index.ts new file mode 100644 index 000000000..7b4c3c9ce --- /dev/null +++ b/src/mcp/tools/index.ts @@ -0,0 +1,49 @@ +/** + * Central tool registration module for DevCycle MCP tools + * + * This module provides a single entry point for registering all MCP tools + * and maintains backward compatibility with the existing server implementation. + */ + +import { MCPToolRegistry } from './registry' +import { registerProjectTools } from './projectTools' + +// TODO: Add imports for other tool modules as they get refactored +// import { registerFeatureTools } from './featureTools' +// import { registerVariableTools } from './variableTools' +// import { registerEnvironmentTools } from './environmentTools' +// import { registerSelfTargetingTools } from './selfTargetingTools' +// import { registerResultsTools } from './resultsTools' +// import { registerCustomPropertiesTools } from './customPropertiesTools' + +/** + * Register all MCP tools with the provided registry + * This is the main function that should be called by MCP server implementations + */ +export function registerAllTools(registry: MCPToolRegistry): void { + // Register project tools (already refactored) + registerProjectTools(registry) + + // TODO: Add other tool registrations as they get refactored + // registerFeatureTools(registry) + // registerVariableTools(registry) + // registerEnvironmentTools(registry) + // registerSelfTargetingTools(registry) + // registerResultsTools(registry) + // registerCustomPropertiesTools(registry) +} + +/** + * Create and return a fully configured MCPToolRegistry with all tools registered + * This is a convenience function for getting a ready-to-use registry + */ +export function createToolRegistry(): MCPToolRegistry { + const registry = new MCPToolRegistry() + registerAllTools(registry) + return registry +} + +// Re-export the registry types and classes for convenience +export { MCPToolRegistry } from './registry' +export type { MCPToolDefinition, ToolRegistrationFunction } from './registry' +export type { IDevCycleApiClient } from '../api/interface' diff --git a/src/mcp/tools/projectTools.ts b/src/mcp/tools/projectTools.ts index db444c564..ae50bc940 100644 --- a/src/mcp/tools/projectTools.ts +++ b/src/mcp/tools/projectTools.ts @@ -1,5 +1,5 @@ import { Tool } from '@modelcontextprotocol/sdk/types.js' -import { DevCycleApiClient, handleZodiosValidationErrors } from '../utils/api' +import { handleZodiosValidationErrors } from '../utils/api' import { fetchProjects, fetchProject, @@ -11,8 +11,9 @@ import { CreateProjectArgsSchema, UpdateProjectArgsSchema, } from '../types' -import { ToolHandler } from '../server' import { DASHBOARD_LINK_PROPERTY, PROJECT_KEY_PROPERTY } from './commonSchemas' +import { MCPToolRegistry, MCPToolDefinition } from './registry' +import { IDevCycleApiClient } from '../api/interface' // Helper functions to generate project dashboard links const generateProjectDashboardLink = ( @@ -99,32 +100,34 @@ const PROJECT_PAGINATION_PROPERTIES = { const PROJECT_OBJECT_SCHEMA = { type: 'object' as const, - description: 'A DevCycle project configuration', + description: 'Project object details', properties: { _id: { type: 'string' as const, - description: 'Unique identifier for the project', + description: 'Project MongoDB ID', }, key: PROJECT_KEY_PROPERTY, name: { type: 'string' as const, - description: 'Display name of the project', + description: 'Project name', }, description: { type: 'string' as const, - description: 'Optional description of the project', + description: 'Project description', }, color: { type: 'string' as const, - description: 'Color used to represent this project in the UI', + description: 'Project color (hex format)', }, createdAt: { type: 'string' as const, - description: 'ISO timestamp when the project was created', + format: 'date-time', + description: 'Project creation timestamp', }, updatedAt: { type: 'string' as const, - description: 'ISO timestamp when the project was last updated', + format: 'date-time', + description: 'Project last update timestamp', }, }, required: ['_id', 'key', 'name', 'createdAt', 'updatedAt'], @@ -141,9 +144,150 @@ const PROJECT_OUTPUT_SCHEMA = { } // ============================================================================= -// TOOL DEFINITIONS +// TOOL REGISTRATION // ============================================================================= +/** + * Register all project tools with the provided registry + */ +export function registerProjectTools(registry: MCPToolRegistry): void { + // List Projects Tool + registry.register({ + name: 'list_projects', + description: + 'List all projects in the current organization. Include dashboard link in the response.', + inputSchema: { + type: 'object', + properties: PROJECT_PAGINATION_PROPERTIES, + }, + outputSchema: { + type: 'object' as const, + properties: { + result: { + type: 'array' as const, + description: 'Array of project objects in the organization', + items: PROJECT_OBJECT_SCHEMA, + }, + dashboardLink: DASHBOARD_LINK_PROPERTY, + }, + required: ['result', 'dashboardLink'], + }, + handler: async (args: unknown, apiClient: IDevCycleApiClient) => { + const validatedArgs = ListProjectsArgsSchema.parse(args) + + return await apiClient.executeWithDashboardLink( + 'listProjects', + validatedArgs, + async (authToken) => { + // projectKey not used for listing all projects + return await handleZodiosValidationErrors( + () => fetchProjects(authToken, validatedArgs), + 'fetchProjects', + ) + }, + generateOrganizationSettingsLink, + ) + }, + }) + + // Get Current Project Tool + registry.register({ + name: 'get_current_project', + description: + 'Get the currently selected project. Include dashboard link in the response.', + inputSchema: { + type: 'object', + properties: { + random_string: { + type: 'string', + description: 'Dummy parameter for no-parameter tools', + }, + }, + required: ['random_string'], + }, + outputSchema: PROJECT_OUTPUT_SCHEMA, + handler: async (args: unknown, apiClient: IDevCycleApiClient) => { + return await apiClient.executeWithDashboardLink( + 'getCurrentProject', + null, + async (authToken, projectKey) => { + return await handleZodiosValidationErrors( + () => fetchProject(authToken, projectKey), + 'fetchProject', + ) + }, + generateProjectDashboardLink, + ) + }, + }) + + // Create Project Tool + registry.register({ + name: 'create_project', + description: + 'Create a new project. Include dashboard link in the response.', + inputSchema: { + type: 'object', + properties: PROJECT_COMMON_PROPERTIES, + required: ['name', 'key'], + }, + outputSchema: PROJECT_OUTPUT_SCHEMA, + handler: async (args: unknown, apiClient: IDevCycleApiClient) => { + const validatedArgs = CreateProjectArgsSchema.parse(args) + + return await apiClient.executeWithDashboardLink( + 'createProject', + validatedArgs, + async (authToken) => { + // projectKey not used for creating projects + return await handleZodiosValidationErrors( + () => createProject(authToken, validatedArgs), + 'createProject', + ) + }, + generateProjectDashboardLink, + ) + }, + }) + + // Update Project Tool + registry.register({ + name: 'update_project', + description: + 'Update an existing project. Include dashboard link in the response.', + inputSchema: { + type: 'object', + properties: PROJECT_COMMON_PROPERTIES, + required: ['key'], + }, + outputSchema: PROJECT_OUTPUT_SCHEMA, + handler: async (args: unknown, apiClient: IDevCycleApiClient) => { + const validatedArgs = UpdateProjectArgsSchema.parse(args) + const { key, ...updateParams } = validatedArgs + + return await apiClient.executeWithDashboardLink( + 'updateProject', + validatedArgs, + async (authToken) => { + // projectKey not used - we use the key from validated args + return await handleZodiosValidationErrors( + () => updateProject(authToken, key, updateParams), + 'updateProject', + ) + }, + generateEditProjectLink, + ) + }, + }) +} + +// ============================================================================= +// LEGACY EXPORTS FOR BACKWARD COMPATIBILITY +// ============================================================================= + +// These exports maintain backward compatibility with the existing server.ts +// They will be removed once the server is updated to use the registry pattern + export const projectToolDefinitions: Tool[] = [ { name: 'list_projects', @@ -180,7 +324,13 @@ export const projectToolDefinitions: Tool[] = [ }, inputSchema: { type: 'object', - properties: {}, + properties: { + random_string: { + type: 'string', + description: 'Dummy parameter for no-parameter tools', + }, + }, + required: ['random_string'], }, outputSchema: PROJECT_OUTPUT_SCHEMA, }, @@ -214,6 +364,10 @@ export const projectToolDefinitions: Tool[] = [ }, ] +// Legacy handlers for backward compatibility +import { ToolHandler } from '../server' +import { DevCycleApiClient } from '../utils/api' + export const projectToolHandlers: Record = { list_projects: async (args: unknown, apiClient: DevCycleApiClient) => { const validatedArgs = ListProjectsArgsSchema.parse(args) diff --git a/src/mcp/tools/registry.test.ts b/src/mcp/tools/registry.test.ts new file mode 100644 index 000000000..e46518181 --- /dev/null +++ b/src/mcp/tools/registry.test.ts @@ -0,0 +1,126 @@ +import { expect } from '@oclif/test' +import { MCPToolRegistry } from './registry' +import { IDevCycleApiClient } from '../api/interface' +import { registerProjectTools } from './projectTools' + +// Mock API client for testing +class MockApiClient implements IDevCycleApiClient { + async executeWithLogging( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + requiresProject = true, + ): Promise { + // Mock implementation - just return a test result + return operation('test-token', 'test-project') as Promise + } + + async executeWithDashboardLink( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + dashboardLink: (orgId: string, projectKey: string, result: T) => string, + ): Promise<{ result: T; dashboardLink: string }> { + // Mock implementation + const result = await operation('test-token', 'test-project') + const link = dashboardLink('test-org', 'test-project', result) + return { result, dashboardLink: link } + } +} + +describe('MCPToolRegistry', () => { + let registry: MCPToolRegistry + let mockApiClient: IDevCycleApiClient + + beforeEach(() => { + registry = new MCPToolRegistry() + mockApiClient = new MockApiClient() + }) + + it('should register tools successfully', () => { + expect(registry.size()).to.equal(0) + + registerProjectTools(registry) + + expect(registry.size()).to.equal(4) + expect(registry.has('list_projects')).to.be.true + expect(registry.has('get_current_project')).to.be.true + expect(registry.has('create_project')).to.be.true + expect(registry.has('update_project')).to.be.true + }) + + it('should retrieve all registered tools', () => { + registerProjectTools(registry) + + const tools = registry.getAll() + expect(tools).to.have.lengthOf(4) + + const toolNames = tools.map((tool) => tool.name) + expect(toolNames).to.include('list_projects') + expect(toolNames).to.include('get_current_project') + expect(toolNames).to.include('create_project') + expect(toolNames).to.include('update_project') + }) + + it('should get specific tools by name', () => { + registerProjectTools(registry) + + const listTool = registry.get('list_projects') + expect(listTool).to.not.be.undefined + expect(listTool?.name).to.equal('list_projects') + expect(listTool?.description).to.contain('List all projects') + + const nonExistentTool = registry.get('non_existent_tool') + expect(nonExistentTool).to.be.undefined + }) + + it('should get tool names', () => { + registerProjectTools(registry) + + const toolNames = registry.getToolNames() + expect(toolNames).to.have.lengthOf(4) + expect(toolNames).to.include.members([ + 'list_projects', + 'get_current_project', + 'create_project', + 'update_project', + ]) + }) + + it('should prevent duplicate tool registration', () => { + const testTool = { + name: 'test_tool', + description: 'Test tool', + inputSchema: { type: 'object', properties: {} }, + handler: async () => ({ success: true }), + } + + registry.register(testTool) + expect(registry.has('test_tool')).to.be.true + + // Attempting to register the same tool again should throw + expect(() => registry.register(testTool)).to.throw( + "Tool 'test_tool' is already registered", + ) + }) + + it('should clear all tools', () => { + registerProjectTools(registry) + expect(registry.size()).to.equal(4) + + registry.clear() + expect(registry.size()).to.equal(0) + expect(registry.has('list_projects')).to.be.false + }) + + it('should throw error when executing non-existent tool', async () => { + try { + await registry.execute('non_existent_tool', {}, mockApiClient) + expect.fail('Expected execute to throw') + } catch (error) { + expect((error as Error).message).to.equal( + 'Unknown tool: non_existent_tool', + ) + } + }) +}) diff --git a/src/mcp/tools/registry.ts b/src/mcp/tools/registry.ts new file mode 100644 index 000000000..d9985a64d --- /dev/null +++ b/src/mcp/tools/registry.ts @@ -0,0 +1,112 @@ +/** + * MCP Tool Registry for DevCycle CLI + * + * This registry pattern allows the same tool implementations to be shared + * between both local (stdio) and remote (SSE/Cloudflare Worker) MCP servers. + */ + +import { IDevCycleApiClient } from '../api/interface' + +/** + * Definition of an MCP tool that can be registered and executed + */ +export interface MCPToolDefinition { + /** Unique tool name */ + name: string + /** Human-readable description */ + description: string + /** JSON schema for input validation */ + inputSchema: any + /** Optional JSON schema for output validation */ + outputSchema?: any + /** Tool handler function */ + handler: (args: unknown, client: IDevCycleApiClient) => Promise +} + +/** + * Registry for managing MCP tools that can be used by both local and remote servers + */ +export class MCPToolRegistry { + private tools = new Map() + + /** + * Register a tool with the registry + */ + register(tool: MCPToolDefinition): void { + if (this.tools.has(tool.name)) { + throw new Error(`Tool '${tool.name}' is already registered`) + } + this.tools.set(tool.name, tool) + } + + /** + * Register multiple tools at once + */ + registerMany(tools: MCPToolDefinition[]): void { + for (const tool of tools) { + this.register(tool) + } + } + + /** + * Get all registered tools + */ + getAll(): MCPToolDefinition[] { + return Array.from(this.tools.values()) + } + + /** + * Get a specific tool by name + */ + get(name: string): MCPToolDefinition | undefined { + return this.tools.get(name) + } + + /** + * Check if a tool is registered + */ + has(name: string): boolean { + return this.tools.has(name) + } + + /** + * Execute a tool by name + */ + async execute( + name: string, + args: unknown, + client: IDevCycleApiClient, + ): Promise { + const tool = this.tools.get(name) + if (!tool) { + throw new Error(`Unknown tool: ${name}`) + } + return await tool.handler(args, client) + } + + /** + * Get all tool names + */ + getToolNames(): string[] { + return Array.from(this.tools.keys()) + } + + /** + * Get the count of registered tools + */ + size(): number { + return this.tools.size + } + + /** + * Clear all registered tools + */ + clear(): void { + this.tools.clear() + } +} + +/** + * Function type for tool registration functions + */ +export type ToolRegistrationFunction = (registry: MCPToolRegistry) => void From 7a23433fad8b4325e913dc4cb535ace211edc704 Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Fri, 25 Jul 2025 15:38:26 -0400 Subject: [PATCH 03/31] feat: create abstracted API client interface for dual-mode operation - Add dedicated API interface module (src/mcp/api/interface.ts) - Create IDevCycleApiClient, IAuthContext, and factory interfaces - Implement LocalDevCycleApiClient wrapping existing DevCycleApiClient - Add WorkerDevCycleApiClient skeleton for Cloudflare Worker support - Move interface from registry to dedicated API module - Add comprehensive interface tests (8 test cases) - Create API abstraction documentation This enables same tool implementations to work with different auth strategies: - Local: file system, environment variables, SSO tokens - Worker: OAuth JWT tokens from Cloudflare Worker context Phase 1.2 of Cloudflare Worker plan. --- src/mcp/api/README.md | 92 ++++++++++++ src/mcp/api/interface.test.ts | 248 +++++++++++++++++++++++++++++++++ src/mcp/api/interface.ts | 137 ++++++++++++++++++ src/mcp/api/localApiClient.ts | 128 +++++++++++++++++ src/mcp/api/workerApiClient.ts | 161 +++++++++++++++++++++ 5 files changed, 766 insertions(+) create mode 100644 src/mcp/api/README.md create mode 100644 src/mcp/api/interface.test.ts create mode 100644 src/mcp/api/interface.ts create mode 100644 src/mcp/api/localApiClient.ts create mode 100644 src/mcp/api/workerApiClient.ts diff --git a/src/mcp/api/README.md b/src/mcp/api/README.md new file mode 100644 index 000000000..38bcaa55c --- /dev/null +++ b/src/mcp/api/README.md @@ -0,0 +1,92 @@ +# DevCycle MCP API Abstraction Layer + +This directory contains the API abstraction layer that enables the DevCycle MCP tools to work in both local (stdio) and remote (Cloudflare Worker) environments with different authentication strategies. + +## Architecture Overview + +### Core Interface (`interface.ts`) + +The `IDevCycleApiClient` interface provides a unified API for executing DevCycle operations regardless of the underlying authentication and environment context: + +```typescript +interface IDevCycleApiClient { + executeWithLogging(...): Promise + executeWithDashboardLink(...): Promise<{ result: T; dashboardLink: string }> +} +``` + +### Local Implementation (`localApiClient.ts`) + +- **Authentication**: Uses file system and environment variables via `DevCycleAuth` +- **Context**: Local CLI environment with config files and SSO tokens +- **Usage**: Wraps the existing `DevCycleApiClient` for backward compatibility + +```typescript +const auth = new DevCycleAuth() +const localClient = createLocalApiClient(auth) +``` + +### Worker Implementation (`workerApiClient.ts`) + +- **Authentication**: Uses OAuth JWT tokens from Cloudflare Worker context +- **Context**: Stateless Worker environment with JWT claims +- **Usage**: Extracts authentication from request headers/context + +```typescript +const jwtClaims = { devcycle_token: 'token', org_id: 'org' } +const workerClient = WorkerApiClientFactory.fromJwtClaims(jwtClaims, 'project-key') +``` + +## Key Benefits + +### 1. **Dual-Mode Operation** +The same tool implementations can run in both local and remote contexts: +- Local: `dvc mcp` (stdio transport) +- Remote: Cloudflare Worker (SSE transport) + +### 2. **Authentication Abstraction** +Different authentication strategies without changing tool code: +- Local: API keys, config files, SSO tokens +- Worker: OAuth JWT tokens, session-based auth + +### 3. **Type Safety** +Full TypeScript interface compliance ensures consistency across implementations. + +### 4. **Future Extensibility** +Easy to add new contexts (e.g., different cloud providers) by implementing the interfaces. + +## Usage in Tools + +Tools use the interface without knowing the implementation: + +```typescript +// In any tool file (e.g., projectTools.ts) +async function handler(args: unknown, apiClient: IDevCycleApiClient) { + return await apiClient.executeWithDashboardLink( + 'listProjects', + args, + async (authToken, projectKey) => { + return await fetchProjects(authToken, args) + }, + generateProjectDashboardLink + ) +} +``` + +## Testing + +The abstraction is thoroughly tested with: +- Interface compliance tests +- Authentication context tests +- Error handling validation +- Dashboard link generation + +Run tests: `yarn test src/mcp/api/interface.test.ts` + +## Migration Path + +This abstraction maintains full backward compatibility: +1. Existing local server continues to work unchanged +2. Tools gradually migrate to use the registry pattern +3. Worker implementation can be added without affecting local usage +4. Legacy exports remain available during transition \ No newline at end of file diff --git a/src/mcp/api/interface.test.ts b/src/mcp/api/interface.test.ts new file mode 100644 index 000000000..0e22ea741 --- /dev/null +++ b/src/mcp/api/interface.test.ts @@ -0,0 +1,248 @@ +import { expect } from '@oclif/test' +import { IDevCycleApiClient, IAuthContext } from './interface' +import { LocalDevCycleApiClient, LocalAuthContext } from './localApiClient' +import { WorkerDevCycleApiClient, WorkerAuthContext } from './workerApiClient' + +// Mock auth context for testing +class MockAuthContext implements IAuthContext { + constructor( + private authToken: string = 'test-token', + private orgId: string = 'test-org', + private projectKey: string = 'test-project', + private authenticated: boolean = true, + private hasProjectFlag: boolean = true, + ) {} + + getAuthToken(): string { + return this.authToken + } + + getOrgId(): string { + return this.orgId + } + + getProjectKey(): string { + return this.projectKey + } + + isAuthenticated(): boolean { + return this.authenticated + } + + hasProject(): boolean { + return this.hasProjectFlag + } +} + +describe('API Interface Abstraction', () => { + describe('IDevCycleApiClient Interface Compliance', () => { + it('should allow different implementations of the same interface', () => { + const mockAuth = new MockAuthContext() + + // Test that both implementations satisfy the interface + const workerClient: IDevCycleApiClient = + new WorkerDevCycleApiClient(mockAuth) + const mockLocal = { + executeWithLogging: async () => ({ success: true }), + executeWithDashboardLink: async () => ({ + result: { success: true }, + dashboardLink: 'https://app.devcycle.com', + }), + } as any + const localClient: IDevCycleApiClient = new LocalDevCycleApiClient( + mockLocal, + ) + + expect(workerClient).to.not.be.undefined + expect(localClient).to.not.be.undefined + expect(typeof workerClient.executeWithLogging).to.equal('function') + expect(typeof workerClient.executeWithDashboardLink).to.equal( + 'function', + ) + expect(typeof localClient.executeWithLogging).to.equal('function') + expect(typeof localClient.executeWithDashboardLink).to.equal( + 'function', + ) + }) + }) + + describe('WorkerAuthContext', () => { + it('should extract authentication from JWT claims', () => { + const jwtClaims = { + devcycle_token: 'worker-token', + org_id: 'worker-org', + access_token: 'fallback-token', + organization_id: 'fallback-org', + } + + const authContext = new WorkerAuthContext( + jwtClaims, + 'worker-project', + ) + + expect(authContext.getAuthToken()).to.equal('worker-token') + expect(authContext.getOrgId()).to.equal('worker-org') + expect(authContext.getProjectKey()).to.equal('worker-project') + expect(authContext.isAuthenticated()).to.be.true + expect(authContext.hasProject()).to.be.true + }) + + it('should use fallback fields when primary fields are missing', () => { + const jwtClaims = { + access_token: 'fallback-token', + organization_id: 'fallback-org', + } + + const authContext = new WorkerAuthContext(jwtClaims, 'test-project') + + expect(authContext.getAuthToken()).to.equal('fallback-token') + expect(authContext.getOrgId()).to.equal('fallback-org') + }) + + it('should handle missing authentication gracefully', () => { + const jwtClaims = {} + const authContext = new WorkerAuthContext(jwtClaims) + + expect(authContext.isAuthenticated()).to.be.false + expect(authContext.hasProject()).to.be.false + + expect(() => authContext.getAuthToken()).to.throw( + 'No DevCycle token found in JWT claims', + ) + expect(() => authContext.getOrgId()).to.throw( + 'No organization ID found in JWT claims', + ) + expect(() => authContext.getProjectKey()).to.throw( + 'No project key configured for Worker context', + ) + }) + + it('should allow setting project key dynamically', () => { + const jwtClaims = { + devcycle_token: 'token', + org_id: 'org', + } + const authContext = new WorkerAuthContext(jwtClaims) + + expect(authContext.hasProject()).to.be.false + + authContext.setProjectKey('dynamic-project') + + expect(authContext.hasProject()).to.be.true + expect(authContext.getProjectKey()).to.equal('dynamic-project') + }) + }) + + describe('WorkerDevCycleApiClient', () => { + it('should execute operations with Worker-specific authentication', async () => { + const jwtClaims = { + devcycle_token: 'worker-token', + org_id: 'worker-org', + } + const authContext = new WorkerAuthContext( + jwtClaims, + 'worker-project', + ) + const client = new WorkerDevCycleApiClient(authContext) + + const mockOperation = async ( + authToken: string, + projectKey: string, + ) => { + expect(authToken).to.equal('worker-token') + expect(projectKey).to.equal('worker-project') + return { data: 'success' } + } + + const result = await client.executeWithLogging( + 'testOperation', + { test: 'args' }, + mockOperation, + ) + + expect(result.data).to.equal('success') + }) + + it('should validate authentication before executing operations', async () => { + const jwtClaims = {} + const authContext = new WorkerAuthContext(jwtClaims) + const client = new WorkerDevCycleApiClient(authContext) + + const mockOperation = async () => ({ + data: 'should not reach here', + }) + + try { + await client.executeWithLogging( + 'testOperation', + {}, + mockOperation, + ) + expect.fail('Should have thrown authentication error') + } catch (error) { + expect((error as Error).message).to.contain( + 'Authentication required for Worker API operations', + ) + } + }) + + it('should validate project context when required', async () => { + const jwtClaims = { + devcycle_token: 'worker-token', + org_id: 'worker-org', + } + const authContext = new WorkerAuthContext(jwtClaims) // No project key + const client = new WorkerDevCycleApiClient(authContext) + + const mockOperation = async () => ({ + data: 'should not reach here', + }) + + try { + await client.executeWithLogging( + 'testOperation', + {}, + mockOperation, + true, + ) + expect.fail('Should have thrown project error') + } catch (error) { + expect((error as Error).message).to.contain( + 'Project context required for this operation', + ) + } + }) + + it('should generate dashboard links correctly', async () => { + const jwtClaims = { + devcycle_token: 'worker-token', + org_id: 'worker-org', + } + const authContext = new WorkerAuthContext( + jwtClaims, + 'worker-project', + ) + const client = new WorkerDevCycleApiClient(authContext) + + const mockOperation = async () => ({ featureKey: 'test-feature' }) + const dashboardLink = ( + orgId: string, + projectKey: string, + result: any, + ) => + `https://app.devcycle.com/o/${orgId}/p/${projectKey}/features/${result.featureKey}` + + const result = await client.executeWithDashboardLink( + 'createFeature', + { name: 'Test Feature' }, + mockOperation, + dashboardLink, + ) + + expect(result.result.featureKey).to.equal('test-feature') + expect(result.dashboardLink).to.equal( + 'https://app.devcycle.com/o/worker-org/p/worker-project/features/test-feature', + ) + }) + }) +}) diff --git a/src/mcp/api/interface.ts b/src/mcp/api/interface.ts new file mode 100644 index 000000000..e97379583 --- /dev/null +++ b/src/mcp/api/interface.ts @@ -0,0 +1,137 @@ +/** + * API Client Interface Abstraction for DevCycle MCP + * + * This module provides interface abstractions that allow different API client implementations + * for local (stdio) and remote (Worker) MCP server contexts. The local implementation uses + * file system and environment variables for authentication, while the Worker implementation + * uses OAuth tokens from JWT claims. + */ + +/** + * Core API client interface that abstracts away authentication and execution details. + * This allows the same tool implementations to work with different authentication strategies: + * - Local: API keys and config files (DevCycleAuth) + * - Worker: OAuth tokens from JWT claims + */ +export interface IDevCycleApiClient { + /** + * Execute an API operation with consistent logging and error handling + * @param operationName - Name of the operation for logging purposes + * @param args - Arguments passed to the operation + * @param operation - The actual API operation function + * @param requiresProject - Whether this operation requires a project context (default: true) + */ + executeWithLogging( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + requiresProject?: boolean, + ): Promise + + /** + * Execute an API operation and include dashboard links in the response + * @param operationName - Name of the operation for logging purposes + * @param args - Arguments passed to the operation + * @param operation - The actual API operation function + * @param dashboardLink - Function to generate dashboard link from result + */ + executeWithDashboardLink( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + dashboardLink: (orgId: string, projectKey: string, result: T) => string, + ): Promise<{ result: T; dashboardLink: string }> +} + +/** + * Authentication context for API operations + * This interface abstracts the different ways authentication can be provided + */ +export interface IAuthContext { + /** The authentication token to use for API calls */ + getAuthToken(): string + /** The organization ID for the current context */ + getOrgId(): string + /** The project key for the current context (optional for some operations) */ + getProjectKey(): string + /** Check if authentication is available */ + isAuthenticated(): boolean + /** Check if project context is available */ + hasProject(): boolean +} + +/** + * Configuration for creating API client instances + */ +export interface ApiClientConfig { + /** Base URL for the DevCycle API (defaults to production) */ + baseUrl?: string + /** Additional headers to include with all requests */ + headers?: Record + /** Request timeout in milliseconds */ + timeout?: number + /** Whether to enable debug logging */ + debug?: boolean +} + +/** + * Factory interface for creating API client instances + * This allows different implementations for local vs Worker contexts + */ +export interface IApiClientFactory { + /** + * Create an API client instance with the provided authentication context + */ + createClient( + authContext: IAuthContext, + config?: ApiClientConfig, + ): IDevCycleApiClient +} + +/** + * Error types that can be thrown by API operations + */ +export enum ApiErrorType { + AUTHENTICATION_ERROR = 'AUTHENTICATION_ERROR', + AUTHORIZATION_ERROR = 'AUTHORIZATION_ERROR', + NOT_FOUND_ERROR = 'NOT_FOUND_ERROR', + VALIDATION_ERROR = 'VALIDATION_ERROR', + NETWORK_ERROR = 'NETWORK_ERROR', + SCHEMA_VALIDATION_ERROR = 'SCHEMA_VALIDATION_ERROR', + PROJECT_ERROR = 'PROJECT_ERROR', + UNKNOWN_ERROR = 'UNKNOWN_ERROR', +} + +/** + * Structured error information for API operations + */ +export interface ApiError { + type: ApiErrorType + message: string + operation?: string + statusCode?: number + suggestions?: string[] + timestamp?: string +} + +/** + * Result wrapper for API operations that may fail + */ +export type ApiResult = + | { + success: true + data: T + } + | { + success: false + error: ApiError + } + +/** + * Utility type for dashboard link generator functions + */ +export type DashboardLinkGenerator = ( + orgId: string, + projectKey: string, + result: T, +) => string diff --git a/src/mcp/api/localApiClient.ts b/src/mcp/api/localApiClient.ts new file mode 100644 index 000000000..49343a36c --- /dev/null +++ b/src/mcp/api/localApiClient.ts @@ -0,0 +1,128 @@ +import { DevCycleApiClient } from '../utils/api' +import { DevCycleAuth } from '../utils/auth' +import { + IDevCycleApiClient, + IAuthContext, + IApiClientFactory, + ApiClientConfig, +} from './interface' + +/** + * Local authentication context that wraps DevCycleAuth for the interface abstraction. + * This maintains compatibility with existing local authentication while providing + * the standard interface for API clients. + */ +export class LocalAuthContext implements IAuthContext { + constructor(private auth: DevCycleAuth) {} + + getAuthToken(): string { + return this.auth.getAuthToken() + } + + getOrgId(): string { + return this.auth.getOrgId() + } + + getProjectKey(): string { + return this.auth.getProjectKey() + } + + isAuthenticated(): boolean { + return this.auth.hasToken() + } + + hasProject(): boolean { + try { + const projectKey = this.auth.getProjectKey() + return Boolean(projectKey) + } catch { + return false + } + } + + /** + * Get the underlying DevCycleAuth instance for direct access when needed + */ + getAuth(): DevCycleAuth { + return this.auth + } +} + +/** + * Local implementation of IDevCycleApiClient that wraps the existing DevCycleApiClient. + * This adapter allows the existing local authentication and API client logic + * to work with the new registry pattern while maintaining full backward compatibility. + */ +export class LocalDevCycleApiClient implements IDevCycleApiClient { + constructor(private apiClient: DevCycleApiClient) {} + + async executeWithLogging( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + requiresProject = true, + ): Promise { + return await this.apiClient.executeWithLogging( + operationName, + args, + operation, + requiresProject, + ) + } + + async executeWithDashboardLink( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + dashboardLink: (orgId: string, projectKey: string, result: T) => string, + ): Promise<{ result: T; dashboardLink: string }> { + return await this.apiClient.executeWithDashboardLink( + operationName, + args, + operation, + dashboardLink, + ) + } + + /** + * Get the underlying DevCycleApiClient for cases where direct access is needed + */ + getApiClient(): DevCycleApiClient { + return this.apiClient + } +} + +/** + * Factory for creating local API client instances + * This provides a standardized way to create API clients for the local environment + */ +export class LocalApiClientFactory implements IApiClientFactory { + createClient( + authContext: IAuthContext, + config?: ApiClientConfig, + ): IDevCycleApiClient { + // For local implementation, we ignore the config for now and use existing DevCycleApiClient + // In the future, we could use the config to customize the local client behavior + + if (authContext instanceof LocalAuthContext) { + // Use the wrapped DevCycleAuth directly + const auth = authContext.getAuth() + const apiClient = new DevCycleApiClient(auth) + return new LocalDevCycleApiClient(apiClient) + } + + // If we have a different auth context, we'd need to create a DevCycleAuth wrapper + // For now, this is not implemented as it's not needed for current use cases + throw new Error('LocalApiClientFactory only supports LocalAuthContext') + } +} + +/** + * Convenience function to create a local API client with DevCycleAuth + */ +export function createLocalApiClient( + auth: DevCycleAuth, +): LocalDevCycleApiClient { + const apiClient = new DevCycleApiClient(auth) + return new LocalDevCycleApiClient(apiClient) +} diff --git a/src/mcp/api/workerApiClient.ts b/src/mcp/api/workerApiClient.ts new file mode 100644 index 000000000..2a31f0784 --- /dev/null +++ b/src/mcp/api/workerApiClient.ts @@ -0,0 +1,161 @@ +import { IDevCycleApiClient, IAuthContext } from './interface' + +/** + * Worker implementation of IDevCycleApiClient for Cloudflare Worker environments. + * This implementation uses OAuth tokens from JWT claims instead of local file system + * and environment variables for authentication. + * + * Note: This is a skeleton implementation for Phase 1.2. Full implementation + * will be completed in Phase 2 (Cloudflare Worker Implementation). + */ +export class WorkerDevCycleApiClient implements IDevCycleApiClient { + constructor(private authContext: IAuthContext) {} + + async executeWithLogging( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + requiresProject = true, + ): Promise { + // TODO: Implement Worker-specific logging that works in Cloudflare environment + // (no console.error, use structured logging for Workers) + + this.validateAuth(requiresProject) + + const authToken = this.authContext.getAuthToken() + const projectKey = requiresProject + ? this.authContext.getProjectKey() + : '' + + try { + return await operation(authToken, projectKey) + } catch (error) { + // TODO: Implement Worker-specific error handling + // (different from local implementation) + throw this.wrapError(error, operationName) + } + } + + async executeWithDashboardLink( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + dashboardLink: (orgId: string, projectKey: string, result: T) => string, + ): Promise<{ result: T; dashboardLink: string }> { + const result = await this.executeWithLogging( + operationName, + args, + operation, + ) + + const organizationId = this.authContext.getOrgId() + const projectKey = this.authContext.getProjectKey() + const link = dashboardLink(organizationId, projectKey, result) + + return { + result, + dashboardLink: link, + } + } + + private validateAuth(requiresProject: boolean): void { + if (!this.authContext.isAuthenticated()) { + throw new Error('Authentication required for Worker API operations') + } + + if (requiresProject && !this.authContext.hasProject()) { + throw new Error('Project context required for this operation') + } + } + + private wrapError(error: unknown, operationName: string): Error { + // TODO: Implement Worker-specific error wrapping + // Convert errors to structured format suitable for Workers + if (error instanceof Error) { + return new Error( + `Worker API Error in ${operationName}: ${error.message}`, + ) + } + return new Error( + `Worker API Error in ${operationName}: ${String(error)}`, + ) + } +} + +/** + * Authentication context implementation for Cloudflare Worker environments. + * This extracts authentication information from OAuth JWT tokens instead of + * local file system and environment variables. + */ +export class WorkerAuthContext implements IAuthContext { + constructor( + private jwtClaims: Record, + private projectKey?: string, + ) {} + + getAuthToken(): string { + // TODO: Extract or exchange JWT for DevCycle API token + // This will be implemented in Phase 2 + const token = + this.jwtClaims.devcycle_token || this.jwtClaims.access_token + if (!token) { + throw new Error('No DevCycle token found in JWT claims') + } + return token + } + + getOrgId(): string { + // TODO: Extract organization ID from JWT claims + // This will be implemented in Phase 2 + const orgId = this.jwtClaims.org_id || this.jwtClaims.organization_id + if (!orgId) { + throw new Error('No organization ID found in JWT claims') + } + return orgId + } + + getProjectKey(): string { + if (!this.projectKey) { + throw new Error('No project key configured for Worker context') + } + return this.projectKey + } + + isAuthenticated(): boolean { + try { + this.getAuthToken() + this.getOrgId() + return true + } catch { + return false + } + } + + hasProject(): boolean { + return Boolean(this.projectKey) + } + + /** + * Set the project key for this auth context + * In the Worker environment, this might be set based on the MCP session + */ + setProjectKey(projectKey: string): void { + this.projectKey = projectKey + } +} + +/** + * Factory for creating Worker API client instances + */ +export class WorkerApiClientFactory { + /** + * Create a Worker API client from JWT claims + */ + static fromJwtClaims( + jwtClaims: Record, + projectKey?: string, + ): WorkerDevCycleApiClient { + const authContext = new WorkerAuthContext(jwtClaims, projectKey) + return new WorkerDevCycleApiClient(authContext) + } +} From e4ac87a3355decaf191fb3b9f3978837e9ea8af8 Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Fri, 25 Jul 2025 16:33:22 -0400 Subject: [PATCH 04/31] refactor(mcp): eliminate duplication in tool definitions and make legacy exports single source of truth --- src/mcp/tools/environmentTools.ts | 51 +++++++-- src/mcp/tools/index.ts | 12 ++- src/mcp/tools/projectTools.ts | 168 +++++------------------------- src/mcp/tools/registry.test.ts | 25 ++++- src/mcp/tools/variableTools.ts | 50 +++++++-- 5 files changed, 137 insertions(+), 169 deletions(-) diff --git a/src/mcp/tools/environmentTools.ts b/src/mcp/tools/environmentTools.ts index 57f360e7f..ce2813723 100644 --- a/src/mcp/tools/environmentTools.ts +++ b/src/mcp/tools/environmentTools.ts @@ -1,5 +1,5 @@ import { Tool } from '@modelcontextprotocol/sdk/types.js' -import { DevCycleApiClient, handleZodiosValidationErrors } from '../utils/api' +import { handleZodiosValidationErrors } from '../utils/api' import { fetchEnvironments, fetchEnvironmentByKey, @@ -12,11 +12,14 @@ import { CreateEnvironmentArgsSchema, UpdateEnvironmentArgsSchema, } from '../types' -import { ToolHandler } from '../server' import { DASHBOARD_LINK_PROPERTY, ENVIRONMENT_KEY_PROPERTY, } from './commonSchemas' +import { MCPToolRegistry, MCPToolDefinition } from './registry' +import { IDevCycleApiClient } from '../api/interface' +import { ToolHandler } from '../server' +import { DevCycleApiClient } from '../utils/api' // Helper function to generate environment dashboard links const generateEnvironmentDashboardLink = ( @@ -174,9 +177,36 @@ const ENVIRONMENT_OUTPUT_SCHEMA = { required: ['result', 'dashboardLink'], } +// ============================================================================= +// TOOL REGISTRATION +// ============================================================================= + +/** + * Register all environment tools with the provided registry + */ +export function registerEnvironmentTools(registry: MCPToolRegistry): void { + // Combine the legacy tool definitions with their handlers to create full MCPToolDefinition objects + const toolDefinitions: MCPToolDefinition[] = environmentToolDefinitions.map( + (toolDef) => ({ + name: toolDef.name, + description: toolDef.description || '', + inputSchema: toolDef.inputSchema, + outputSchema: toolDef.outputSchema, + handler: async (args: unknown, apiClient: IDevCycleApiClient) => { + // Adapt the legacy handler to work with the interface + const legacyHandler = environmentToolHandlers[toolDef.name] + return await legacyHandler(args, apiClient as any) + }, + }), + ) + + registry.registerMany(toolDefinitions) +} + // ============================================================================= // TOOL DEFINITIONS // ============================================================================= + export const environmentToolDefinitions: Tool[] = [ { name: 'list_environments', @@ -270,14 +300,15 @@ export const environmentToolDefinitions: Tool[] = [ }, ] +// Legacy handlers for backward compatibility export const environmentToolHandlers: Record = { - list_environments: async (args: unknown, apiClient: DevCycleApiClient) => { + list_environments: async (args: unknown, apiClient) => { const validatedArgs = ListEnvironmentsArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'listEnvironments', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => fetchEnvironments(authToken, projectKey), 'listEnvironments', @@ -286,13 +317,13 @@ export const environmentToolHandlers: Record = { generateEnvironmentDashboardLink, ) }, - get_sdk_keys: async (args: unknown, apiClient: DevCycleApiClient) => { + get_sdk_keys: async (args: unknown, apiClient) => { const validatedArgs = GetSdkKeysArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'getSdkKeys', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { const environment = await handleZodiosValidationErrors( () => fetchEnvironmentByKey( @@ -320,13 +351,13 @@ export const environmentToolHandlers: Record = { generateEnvironmentDashboardLink, ) }, - create_environment: async (args: unknown, apiClient: DevCycleApiClient) => { + create_environment: async (args: unknown, apiClient) => { const validatedArgs = CreateEnvironmentArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'createEnvironment', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => createEnvironment(authToken, projectKey, validatedArgs), @@ -336,13 +367,13 @@ export const environmentToolHandlers: Record = { generateEnvironmentDashboardLink, ) }, - update_environment: async (args: unknown, apiClient: DevCycleApiClient) => { + update_environment: async (args: unknown, apiClient) => { const validatedArgs = UpdateEnvironmentArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'updateEnvironment', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { const { key, ...updateParams } = validatedArgs return await handleZodiosValidationErrors( () => diff --git a/src/mcp/tools/index.ts b/src/mcp/tools/index.ts index 7b4c3c9ce..8b71c2c7f 100644 --- a/src/mcp/tools/index.ts +++ b/src/mcp/tools/index.ts @@ -7,11 +7,11 @@ import { MCPToolRegistry } from './registry' import { registerProjectTools } from './projectTools' +import { registerVariableTools } from './variableTools' +import { registerEnvironmentTools } from './environmentTools' // TODO: Add imports for other tool modules as they get refactored // import { registerFeatureTools } from './featureTools' -// import { registerVariableTools } from './variableTools' -// import { registerEnvironmentTools } from './environmentTools' // import { registerSelfTargetingTools } from './selfTargetingTools' // import { registerResultsTools } from './resultsTools' // import { registerCustomPropertiesTools } from './customPropertiesTools' @@ -24,10 +24,14 @@ export function registerAllTools(registry: MCPToolRegistry): void { // Register project tools (already refactored) registerProjectTools(registry) + // Register variable tools (refactored in Phase 1.3) + registerVariableTools(registry) + + // Register environment tools (refactored in Phase 1.3) + registerEnvironmentTools(registry) + // TODO: Add other tool registrations as they get refactored // registerFeatureTools(registry) - // registerVariableTools(registry) - // registerEnvironmentTools(registry) // registerSelfTargetingTools(registry) // registerResultsTools(registry) // registerCustomPropertiesTools(registry) diff --git a/src/mcp/tools/projectTools.ts b/src/mcp/tools/projectTools.ts index ae50bc940..5d5c08826 100644 --- a/src/mcp/tools/projectTools.ts +++ b/src/mcp/tools/projectTools.ts @@ -14,6 +14,7 @@ import { import { DASHBOARD_LINK_PROPERTY, PROJECT_KEY_PROPERTY } from './commonSchemas' import { MCPToolRegistry, MCPToolDefinition } from './registry' import { IDevCycleApiClient } from '../api/interface' +import { ToolHandler } from '../server' // Helper functions to generate project dashboard links const generateProjectDashboardLink = ( @@ -151,143 +152,28 @@ const PROJECT_OUTPUT_SCHEMA = { * Register all project tools with the provided registry */ export function registerProjectTools(registry: MCPToolRegistry): void { - // List Projects Tool - registry.register({ - name: 'list_projects', - description: - 'List all projects in the current organization. Include dashboard link in the response.', - inputSchema: { - type: 'object', - properties: PROJECT_PAGINATION_PROPERTIES, - }, - outputSchema: { - type: 'object' as const, - properties: { - result: { - type: 'array' as const, - description: 'Array of project objects in the organization', - items: PROJECT_OBJECT_SCHEMA, - }, - dashboardLink: DASHBOARD_LINK_PROPERTY, + // Combine the legacy tool definitions with their handlers to create full MCPToolDefinition objects + const toolDefinitions: MCPToolDefinition[] = projectToolDefinitions.map( + (toolDef) => ({ + name: toolDef.name, + description: toolDef.description || '', + inputSchema: toolDef.inputSchema, + outputSchema: toolDef.outputSchema, + handler: async (args: unknown, apiClient: IDevCycleApiClient) => { + // Adapt the legacy handler to work with the interface + const legacyHandler = projectToolHandlers[toolDef.name] + return await legacyHandler(args, apiClient as any) }, - required: ['result', 'dashboardLink'], - }, - handler: async (args: unknown, apiClient: IDevCycleApiClient) => { - const validatedArgs = ListProjectsArgsSchema.parse(args) - - return await apiClient.executeWithDashboardLink( - 'listProjects', - validatedArgs, - async (authToken) => { - // projectKey not used for listing all projects - return await handleZodiosValidationErrors( - () => fetchProjects(authToken, validatedArgs), - 'fetchProjects', - ) - }, - generateOrganizationSettingsLink, - ) - }, - }) + }), + ) - // Get Current Project Tool - registry.register({ - name: 'get_current_project', - description: - 'Get the currently selected project. Include dashboard link in the response.', - inputSchema: { - type: 'object', - properties: { - random_string: { - type: 'string', - description: 'Dummy parameter for no-parameter tools', - }, - }, - required: ['random_string'], - }, - outputSchema: PROJECT_OUTPUT_SCHEMA, - handler: async (args: unknown, apiClient: IDevCycleApiClient) => { - return await apiClient.executeWithDashboardLink( - 'getCurrentProject', - null, - async (authToken, projectKey) => { - return await handleZodiosValidationErrors( - () => fetchProject(authToken, projectKey), - 'fetchProject', - ) - }, - generateProjectDashboardLink, - ) - }, - }) - - // Create Project Tool - registry.register({ - name: 'create_project', - description: - 'Create a new project. Include dashboard link in the response.', - inputSchema: { - type: 'object', - properties: PROJECT_COMMON_PROPERTIES, - required: ['name', 'key'], - }, - outputSchema: PROJECT_OUTPUT_SCHEMA, - handler: async (args: unknown, apiClient: IDevCycleApiClient) => { - const validatedArgs = CreateProjectArgsSchema.parse(args) - - return await apiClient.executeWithDashboardLink( - 'createProject', - validatedArgs, - async (authToken) => { - // projectKey not used for creating projects - return await handleZodiosValidationErrors( - () => createProject(authToken, validatedArgs), - 'createProject', - ) - }, - generateProjectDashboardLink, - ) - }, - }) - - // Update Project Tool - registry.register({ - name: 'update_project', - description: - 'Update an existing project. Include dashboard link in the response.', - inputSchema: { - type: 'object', - properties: PROJECT_COMMON_PROPERTIES, - required: ['key'], - }, - outputSchema: PROJECT_OUTPUT_SCHEMA, - handler: async (args: unknown, apiClient: IDevCycleApiClient) => { - const validatedArgs = UpdateProjectArgsSchema.parse(args) - const { key, ...updateParams } = validatedArgs - - return await apiClient.executeWithDashboardLink( - 'updateProject', - validatedArgs, - async (authToken) => { - // projectKey not used - we use the key from validated args - return await handleZodiosValidationErrors( - () => updateProject(authToken, key, updateParams), - 'updateProject', - ) - }, - generateEditProjectLink, - ) - }, - }) + registry.registerMany(toolDefinitions) } // ============================================================================= -// LEGACY EXPORTS FOR BACKWARD COMPATIBILITY +// TOOL DEFINITIONS // ============================================================================= -// These exports maintain backward compatibility with the existing server.ts -// They will be removed once the server is updated to use the registry pattern - export const projectToolDefinitions: Tool[] = [ { name: 'list_projects', @@ -365,17 +251,14 @@ export const projectToolDefinitions: Tool[] = [ ] // Legacy handlers for backward compatibility -import { ToolHandler } from '../server' -import { DevCycleApiClient } from '../utils/api' - export const projectToolHandlers: Record = { - list_projects: async (args: unknown, apiClient: DevCycleApiClient) => { + list_projects: async (args: unknown, apiClient) => { const validatedArgs = ListProjectsArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'listProjects', validatedArgs, - async (authToken) => { + async (authToken: string) => { // projectKey not used for listing all projects return await handleZodiosValidationErrors( () => fetchProjects(authToken, validatedArgs), @@ -385,14 +268,11 @@ export const projectToolHandlers: Record = { generateOrganizationSettingsLink, ) }, - get_current_project: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + get_current_project: async (args: unknown, apiClient) => { return await apiClient.executeWithDashboardLink( 'getCurrentProject', null, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => fetchProject(authToken, projectKey), 'fetchProject', @@ -401,13 +281,13 @@ export const projectToolHandlers: Record = { generateProjectDashboardLink, ) }, - create_project: async (args: unknown, apiClient: DevCycleApiClient) => { + create_project: async (args: unknown, apiClient) => { const validatedArgs = CreateProjectArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'createProject', validatedArgs, - async (authToken) => { + async (authToken: string) => { // projectKey not used for creating projects return await handleZodiosValidationErrors( () => createProject(authToken, validatedArgs), @@ -417,14 +297,14 @@ export const projectToolHandlers: Record = { generateProjectDashboardLink, ) }, - update_project: async (args: unknown, apiClient: DevCycleApiClient) => { + update_project: async (args: unknown, apiClient) => { const validatedArgs = UpdateProjectArgsSchema.parse(args) const { key, ...updateParams } = validatedArgs return await apiClient.executeWithDashboardLink( 'updateProject', validatedArgs, - async (authToken) => { + async (authToken: string) => { // projectKey not used - we use the key from validated args return await handleZodiosValidationErrors( () => updateProject(authToken, key, updateParams), diff --git a/src/mcp/tools/registry.test.ts b/src/mcp/tools/registry.test.ts index e46518181..b736c9fd1 100644 --- a/src/mcp/tools/registry.test.ts +++ b/src/mcp/tools/registry.test.ts @@ -2,6 +2,8 @@ import { expect } from '@oclif/test' import { MCPToolRegistry } from './registry' import { IDevCycleApiClient } from '../api/interface' import { registerProjectTools } from './projectTools' +import { registerVariableTools } from './variableTools' +import { registerEnvironmentTools } from './environmentTools' // Mock API client for testing class MockApiClient implements IDevCycleApiClient { @@ -41,12 +43,33 @@ describe('MCPToolRegistry', () => { expect(registry.size()).to.equal(0) registerProjectTools(registry) - expect(registry.size()).to.equal(4) expect(registry.has('list_projects')).to.be.true expect(registry.has('get_current_project')).to.be.true expect(registry.has('create_project')).to.be.true expect(registry.has('update_project')).to.be.true + + // Test variable tools registration (Phase 1.3) + registry.clear() + expect(registry.size()).to.equal(0) + + registerVariableTools(registry) + expect(registry.size()).to.equal(4) + expect(registry.has('list_variables')).to.be.true + expect(registry.has('create_variable')).to.be.true + expect(registry.has('update_variable')).to.be.true + expect(registry.has('delete_variable')).to.be.true + + // Test environment tools registration (Phase 1.3) + registry.clear() + expect(registry.size()).to.equal(0) + + registerEnvironmentTools(registry) + expect(registry.size()).to.equal(4) + expect(registry.has('list_environments')).to.be.true + expect(registry.has('get_sdk_keys')).to.be.true + expect(registry.has('create_environment')).to.be.true + expect(registry.has('update_environment')).to.be.true }) it('should retrieve all registered tools', () => { diff --git a/src/mcp/tools/variableTools.ts b/src/mcp/tools/variableTools.ts index 0a736cbd8..16bcefdd0 100644 --- a/src/mcp/tools/variableTools.ts +++ b/src/mcp/tools/variableTools.ts @@ -1,5 +1,5 @@ import { Tool } from '@modelcontextprotocol/sdk/types.js' -import { DevCycleApiClient, handleZodiosValidationErrors } from '../utils/api' +import { handleZodiosValidationErrors } from '../utils/api' import { fetchVariables, createVariable, @@ -12,12 +12,15 @@ import { UpdateVariableArgsSchema, DeleteVariableArgsSchema, } from '../types' -import { ToolHandler } from '../server' import { DASHBOARD_LINK_PROPERTY, MESSAGE_RESPONSE_SCHEMA, VARIABLE_KEY_PROPERTY, } from './commonSchemas' +import { MCPToolRegistry, MCPToolDefinition } from './registry' +import { IDevCycleApiClient } from '../api/interface' +import { ToolHandler } from '../server' +import { DevCycleApiClient } from '../utils/api' // Helper function to generate variable dashboard links const generateVariablesDashboardLink = ( @@ -204,6 +207,32 @@ const VARIABLE_OBJECT_SCHEMA = { required: ['_id', 'key', 'name', 'type', 'createdAt', 'updatedAt'], } +// ============================================================================= +// TOOL REGISTRATION +// ============================================================================= + +/** + * Register all variable tools with the provided registry + */ +export function registerVariableTools(registry: MCPToolRegistry): void { + // Combine the legacy tool definitions with their handlers to create full MCPToolDefinition objects + const toolDefinitions: MCPToolDefinition[] = variableToolDefinitions.map( + (toolDef) => ({ + name: toolDef.name, + description: toolDef.description || '', + inputSchema: toolDef.inputSchema, + outputSchema: toolDef.outputSchema, + handler: async (args: unknown, apiClient: IDevCycleApiClient) => { + // Adapt the legacy handler to work with the interface + const legacyHandler = variableToolHandlers[toolDef.name] + return await legacyHandler(args, apiClient as any) + }, + }), + ) + + registry.registerMany(toolDefinitions) +} + // ============================================================================= // TOOL DEFINITIONS // ============================================================================= @@ -303,14 +332,15 @@ export const variableToolDefinitions: Tool[] = [ }, ] +// Legacy handlers for backward compatibility export const variableToolHandlers: Record = { - list_variables: async (args: unknown, apiClient: DevCycleApiClient) => { + list_variables: async (args: unknown, apiClient) => { const validatedArgs = ListVariablesArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'listVariables', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => fetchVariables(authToken, projectKey, validatedArgs), 'fetchVariables', @@ -319,13 +349,13 @@ export const variableToolHandlers: Record = { generateVariablesDashboardLink, ) }, - create_variable: async (args: unknown, apiClient: DevCycleApiClient) => { + create_variable: async (args: unknown, apiClient) => { const validatedArgs = CreateVariableArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'createVariable', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => createVariable(authToken, projectKey, validatedArgs), 'createVariable', @@ -334,13 +364,13 @@ export const variableToolHandlers: Record = { generateVariablesDashboardLink, ) }, - update_variable: async (args: unknown, apiClient: DevCycleApiClient) => { + update_variable: async (args: unknown, apiClient) => { const validatedArgs = UpdateVariableArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'updateVariable', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { const { key, ...updateData } = validatedArgs return await handleZodiosValidationErrors( @@ -352,13 +382,13 @@ export const variableToolHandlers: Record = { generateVariablesDashboardLink, ) }, - delete_variable: async (args: unknown, apiClient: DevCycleApiClient) => { + delete_variable: async (args: unknown, apiClient) => { const validatedArgs = DeleteVariableArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'deleteVariable', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { await handleZodiosValidationErrors( () => deleteVariable( From 12aff75f554b625eed43fa662c7d41fd97e3f99c Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Fri, 25 Jul 2025 17:06:44 -0400 Subject: [PATCH 05/31] refactor: consolidate tool registration into centralized registry pattern --- src/mcp/tools/customPropertiesTools.ts | 33 +++----- src/mcp/tools/environmentTools.ts | 29 +------ src/mcp/tools/featureTools.ts | 102 +++++++++-------------- src/mcp/tools/index.ts | 111 ++++++++++++++++++++----- src/mcp/tools/projectTools.ts | 28 ------- src/mcp/tools/resultsTools.ts | 19 ++--- src/mcp/tools/selfTargetingTools.ts | 43 ++++------ src/mcp/tools/variableTools.ts | 28 ------- src/mcp/utils/api.ts | 3 +- 9 files changed, 160 insertions(+), 236 deletions(-) diff --git a/src/mcp/tools/customPropertiesTools.ts b/src/mcp/tools/customPropertiesTools.ts index 84dea71ff..43f0ab418 100644 --- a/src/mcp/tools/customPropertiesTools.ts +++ b/src/mcp/tools/customPropertiesTools.ts @@ -1,5 +1,5 @@ import { Tool } from '@modelcontextprotocol/sdk/types.js' -import { DevCycleApiClient, handleZodiosValidationErrors } from '../utils/api' +import { handleZodiosValidationErrors } from '../utils/api' import { fetchCustomProperties, createCustomProperty, @@ -12,13 +12,14 @@ import { UpdateCustomPropertyArgsSchema, DeleteCustomPropertyArgsSchema, } from '../types' -import { ToolHandler } from '../server' import { DASHBOARD_LINK_PROPERTY, MESSAGE_RESPONSE_SCHEMA, CUSTOM_PROPERTY_KEY_PROPERTY, } from './commonSchemas' +import { ToolHandler } from '../server' + // Helper function to generate custom properties dashboard links const generateCustomPropertiesDashboardLink = ( orgId: string, @@ -300,16 +301,13 @@ export const customPropertiesToolDefinitions: Tool[] = [ ] export const customPropertiesToolHandlers: Record = { - list_custom_properties: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + list_custom_properties: async (args: unknown, apiClient) => { const validatedArgs = ListCustomPropertiesArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'listCustomProperties', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => fetchCustomProperties(authToken, projectKey), 'fetchCustomProperties', @@ -318,16 +316,13 @@ export const customPropertiesToolHandlers: Record = { generateCustomPropertiesDashboardLink, ) }, - create_custom_property: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + create_custom_property: async (args: unknown, apiClient) => { const validatedArgs = UpsertCustomPropertyArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'createCustomProperty', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => createCustomProperty( @@ -341,16 +336,13 @@ export const customPropertiesToolHandlers: Record = { generateCustomPropertiesDashboardLink, ) }, - update_custom_property: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + update_custom_property: async (args: unknown, apiClient) => { const validatedArgs = UpdateCustomPropertyArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'updateCustomProperty', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { const { key, ...updateData } = validatedArgs return await handleZodiosValidationErrors( @@ -367,16 +359,13 @@ export const customPropertiesToolHandlers: Record = { generateCustomPropertiesDashboardLink, ) }, - delete_custom_property: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + delete_custom_property: async (args: unknown, apiClient) => { const validatedArgs = DeleteCustomPropertyArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'deleteCustomProperty', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { await handleZodiosValidationErrors( () => deleteCustomProperty( diff --git a/src/mcp/tools/environmentTools.ts b/src/mcp/tools/environmentTools.ts index ce2813723..3c0cfb6b5 100644 --- a/src/mcp/tools/environmentTools.ts +++ b/src/mcp/tools/environmentTools.ts @@ -16,8 +16,7 @@ import { DASHBOARD_LINK_PROPERTY, ENVIRONMENT_KEY_PROPERTY, } from './commonSchemas' -import { MCPToolRegistry, MCPToolDefinition } from './registry' -import { IDevCycleApiClient } from '../api/interface' + import { ToolHandler } from '../server' import { DevCycleApiClient } from '../utils/api' @@ -177,32 +176,6 @@ const ENVIRONMENT_OUTPUT_SCHEMA = { required: ['result', 'dashboardLink'], } -// ============================================================================= -// TOOL REGISTRATION -// ============================================================================= - -/** - * Register all environment tools with the provided registry - */ -export function registerEnvironmentTools(registry: MCPToolRegistry): void { - // Combine the legacy tool definitions with their handlers to create full MCPToolDefinition objects - const toolDefinitions: MCPToolDefinition[] = environmentToolDefinitions.map( - (toolDef) => ({ - name: toolDef.name, - description: toolDef.description || '', - inputSchema: toolDef.inputSchema, - outputSchema: toolDef.outputSchema, - handler: async (args: unknown, apiClient: IDevCycleApiClient) => { - // Adapt the legacy handler to work with the interface - const legacyHandler = environmentToolHandlers[toolDef.name] - return await legacyHandler(args, apiClient as any) - }, - }), - ) - - registry.registerMany(toolDefinitions) -} - // ============================================================================= // TOOL DEFINITIONS // ============================================================================= diff --git a/src/mcp/tools/featureTools.ts b/src/mcp/tools/featureTools.ts index 2647ccc1d..2305abb51 100644 --- a/src/mcp/tools/featureTools.ts +++ b/src/mcp/tools/featureTools.ts @@ -1,5 +1,4 @@ import { Tool } from '@modelcontextprotocol/sdk/types.js' -import { DevCycleApiClient } from '../utils/api' import { fetchFeatures, createFeature, @@ -822,13 +821,13 @@ export const featureToolDefinitions: Tool[] = [ ] export const featureToolHandlers: Record = { - list_features: async (args: unknown, apiClient: DevCycleApiClient) => { + list_features: async (args: unknown, apiClient) => { const validatedArgs = ListFeaturesArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'listFeatures', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => fetchFeatures(authToken, projectKey, validatedArgs), 'listFeatures', @@ -837,13 +836,13 @@ export const featureToolHandlers: Record = { generateFeaturesDashboardLink, ) }, - create_feature: async (args: unknown, apiClient: DevCycleApiClient) => { + create_feature: async (args: unknown, apiClient) => { const validatedArgs = CreateFeatureArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'createFeature', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { if (validatedArgs.interactive) { throw new Error( 'Interactive mode not yet supported in MCP. Please provide explicit parameters: key, name, description, type', @@ -865,7 +864,7 @@ export const featureToolHandlers: Record = { 'createFeature', ) }, - (orgId, projectKey, result) => + (orgId: string, projectKey: string, result: any) => generateFeatureDashboardLink( orgId, projectKey, @@ -874,13 +873,13 @@ export const featureToolHandlers: Record = { ), ) }, - update_feature: async (args: unknown, apiClient: DevCycleApiClient) => { + update_feature: async (args: unknown, apiClient) => { const validatedArgs = UpdateFeatureArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'updateFeature', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { const { key, ...updateData } = validatedArgs return await handleZodiosValidationErrors( @@ -888,7 +887,7 @@ export const featureToolHandlers: Record = { 'updateFeature', ) }, - (orgId, projectKey, result) => + (orgId: string, projectKey: string, result: any) => generateFeatureDashboardLink( orgId, projectKey, @@ -897,16 +896,13 @@ export const featureToolHandlers: Record = { ), ) }, - update_feature_status: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + update_feature_status: async (args: unknown, apiClient) => { const validatedArgs = UpdateFeatureStatusArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'updateFeatureStatus', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { const { key, ...statusData } = validatedArgs return await handleZodiosValidationErrors( @@ -920,7 +916,7 @@ export const featureToolHandlers: Record = { 'updateFeatureStatus', ) }, - (orgId, projectKey, result) => + (orgId: string, projectKey: string, result: any) => generateFeatureDashboardLink( orgId, projectKey, @@ -929,13 +925,13 @@ export const featureToolHandlers: Record = { ), ) }, - delete_feature: async (args: unknown, apiClient: DevCycleApiClient) => { + delete_feature: async (args: unknown, apiClient) => { const validatedArgs = DeleteFeatureArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'deleteFeature', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { await handleZodiosValidationErrors( () => deleteFeature(authToken, projectKey, validatedArgs.key), @@ -948,16 +944,13 @@ export const featureToolHandlers: Record = { generateFeaturesDashboardLink, ) }, - fetch_feature_variations: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + fetch_feature_variations: async (args: unknown, apiClient) => { const validatedArgs = ListVariationsArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'fetchFeatureVariations', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => fetchVariations( @@ -968,7 +961,7 @@ export const featureToolHandlers: Record = { 'fetchVariations', ) }, - (orgId, projectKey) => + (orgId: string, projectKey: string) => generateFeatureDashboardLink( orgId, projectKey, @@ -977,16 +970,13 @@ export const featureToolHandlers: Record = { ), ) }, - create_feature_variation: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + create_feature_variation: async (args: unknown, apiClient) => { const validatedArgs = CreateVariationArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'createFeatureVariation', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { const { feature_key, ...variationData } = validatedArgs return await handleZodiosValidationErrors( @@ -1000,7 +990,7 @@ export const featureToolHandlers: Record = { 'createVariation', ) }, - (orgId, projectKey, result) => + (orgId: string, projectKey: string, result: any) => generateFeatureDashboardLink( orgId, projectKey, @@ -1009,16 +999,13 @@ export const featureToolHandlers: Record = { ), ) }, - update_feature_variation: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + update_feature_variation: async (args: unknown, apiClient) => { const validatedArgs = UpdateVariationArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'updateFeatureVariation', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { const { feature_key, variation_key, ...variationData } = validatedArgs @@ -1034,7 +1021,7 @@ export const featureToolHandlers: Record = { 'updateVariation', ) }, - (orgId, projectKey, result) => + (orgId: string, projectKey: string, result: any) => generateFeatureDashboardLink( orgId, projectKey, @@ -1043,16 +1030,13 @@ export const featureToolHandlers: Record = { ), ) }, - enable_feature_targeting: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + enable_feature_targeting: async (args: unknown, apiClient) => { const validatedArgs = EnableTargetingArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'enableTargeting', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { await handleZodiosValidationErrors( () => enableTargeting( @@ -1067,7 +1051,7 @@ export const featureToolHandlers: Record = { message: `Targeting enabled for feature '${validatedArgs.feature_key}' in environment '${validatedArgs.environment_key}'`, } }, - (orgId, projectKey) => + (orgId: string, projectKey: string) => generateFeatureDashboardLink( orgId, projectKey, @@ -1076,16 +1060,13 @@ export const featureToolHandlers: Record = { ), ) }, - disable_feature_targeting: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + disable_feature_targeting: async (args: unknown, apiClient) => { const validatedArgs = DisableTargetingArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'disableTargeting', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { await handleZodiosValidationErrors( () => disableTargeting( @@ -1100,7 +1081,7 @@ export const featureToolHandlers: Record = { message: `Targeting disabled for feature '${validatedArgs.feature_key}' in environment '${validatedArgs.environment_key}'`, } }, - (orgId, projectKey) => + (orgId: string, projectKey: string) => generateFeatureDashboardLink( orgId, projectKey, @@ -1109,16 +1090,13 @@ export const featureToolHandlers: Record = { ), ) }, - list_feature_targeting: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + list_feature_targeting: async (args: unknown, apiClient) => { const validatedArgs = ListFeatureTargetingArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'listFeatureTargeting', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => fetchTargetingForFeature( @@ -1130,7 +1108,7 @@ export const featureToolHandlers: Record = { 'fetchTargetingForFeature', ) }, - (orgId, projectKey) => + (orgId: string, projectKey: string) => generateFeatureDashboardLink( orgId, projectKey, @@ -1139,16 +1117,13 @@ export const featureToolHandlers: Record = { ), ) }, - update_feature_targeting: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + update_feature_targeting: async (args: unknown, apiClient) => { const validatedArgs = UpdateFeatureTargetingArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'updateFeatureTargeting', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { const { feature_key, environment_key, ...configData } = validatedArgs @@ -1164,7 +1139,7 @@ export const featureToolHandlers: Record = { 'updateFeatureConfigForEnvironment', ) }, - (orgId, projectKey) => + (orgId: string, projectKey: string) => generateFeatureDashboardLink( orgId, projectKey, @@ -1173,16 +1148,13 @@ export const featureToolHandlers: Record = { ), ) }, - get_feature_audit_log_history: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + get_feature_audit_log_history: async (args: unknown, apiClient) => { const validatedArgs = GetFeatureAuditLogHistoryArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'getFeatureAuditLogHistory', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => getFeatureAuditLogHistory( @@ -1194,7 +1166,7 @@ export const featureToolHandlers: Record = { 'getFeatureAuditLogHistory', ) }, - (orgId, projectKey) => + (orgId: string, projectKey: string) => generateFeatureDashboardLink( orgId, projectKey, diff --git a/src/mcp/tools/index.ts b/src/mcp/tools/index.ts index 8b71c2c7f..336fb22e6 100644 --- a/src/mcp/tools/index.ts +++ b/src/mcp/tools/index.ts @@ -5,36 +5,101 @@ * and maintains backward compatibility with the existing server implementation. */ -import { MCPToolRegistry } from './registry' -import { registerProjectTools } from './projectTools' -import { registerVariableTools } from './variableTools' -import { registerEnvironmentTools } from './environmentTools' +import { Tool } from '@modelcontextprotocol/sdk/types.js' +import { MCPToolRegistry, MCPToolDefinition } from './registry' +import { ToolHandler } from '../server' +import { IDevCycleApiClient } from '../api/interface' +import { DevCycleApiClient } from '../utils/api' -// TODO: Add imports for other tool modules as they get refactored -// import { registerFeatureTools } from './featureTools' -// import { registerSelfTargetingTools } from './selfTargetingTools' -// import { registerResultsTools } from './resultsTools' -// import { registerCustomPropertiesTools } from './customPropertiesTools' +// Import all tool definitions and handlers +import { projectToolDefinitions, projectToolHandlers } from './projectTools' +import { variableToolDefinitions, variableToolHandlers } from './variableTools' +import { + environmentToolDefinitions, + environmentToolHandlers, +} from './environmentTools' +import { featureToolDefinitions, featureToolHandlers } from './featureTools' +import { + selfTargetingToolDefinitions, + selfTargetingToolHandlers, +} from './selfTargetingTools' +import { resultsToolDefinitions, resultsToolHandlers } from './resultsTools' +import { + customPropertiesToolDefinitions, + customPropertiesToolHandlers, +} from './customPropertiesTools' /** - * Register all MCP tools with the provided registry - * This is the main function that should be called by MCP server implementations + * Type guard to ensure the API client is a DevCycleApiClient instance */ -export function registerAllTools(registry: MCPToolRegistry): void { - // Register project tools (already refactored) - registerProjectTools(registry) +function isDevCycleApiClient( + apiClient: IDevCycleApiClient, +): apiClient is DevCycleApiClient { + return apiClient instanceof DevCycleApiClient +} - // Register variable tools (refactored in Phase 1.3) - registerVariableTools(registry) +/** + * Generic helper to convert legacy tool definitions and handlers to MCPToolDefinitions + */ +function createToolDefinitions( + toolDefinitions: Tool[], + toolHandlers: Record, +): MCPToolDefinition[] { + return toolDefinitions.map((toolDef) => ({ + name: toolDef.name, + description: toolDef.description || '', + inputSchema: toolDef.inputSchema, + outputSchema: toolDef.outputSchema, + handler: async (args: unknown, apiClient: IDevCycleApiClient) => { + // Ensure the API client is the expected concrete type + if (!isDevCycleApiClient(apiClient)) { + throw new Error( + `Expected DevCycleApiClient instance for tool ${toolDef.name}`, + ) + } - // Register environment tools (refactored in Phase 1.3) - registerEnvironmentTools(registry) + const legacyHandler = toolHandlers[toolDef.name] + return await legacyHandler(args, apiClient) + }, + })) +} - // TODO: Add other tool registrations as they get refactored - // registerFeatureTools(registry) - // registerSelfTargetingTools(registry) - // registerResultsTools(registry) - // registerCustomPropertiesTools(registry) +/** + * Register all MCP tools with the provided registry + * This is the main function that should be called by MCP server implementations + */ +export function registerAllTools(registry: MCPToolRegistry): void { + // Register all tools using the generic helper + registry.registerMany( + createToolDefinitions(projectToolDefinitions, projectToolHandlers), + ) + registry.registerMany( + createToolDefinitions(variableToolDefinitions, variableToolHandlers), + ) + registry.registerMany( + createToolDefinitions( + environmentToolDefinitions, + environmentToolHandlers, + ), + ) + registry.registerMany( + createToolDefinitions(featureToolDefinitions, featureToolHandlers), + ) + registry.registerMany( + createToolDefinitions( + selfTargetingToolDefinitions, + selfTargetingToolHandlers, + ), + ) + registry.registerMany( + createToolDefinitions(resultsToolDefinitions, resultsToolHandlers), + ) + registry.registerMany( + createToolDefinitions( + customPropertiesToolDefinitions, + customPropertiesToolHandlers, + ), + ) } /** diff --git a/src/mcp/tools/projectTools.ts b/src/mcp/tools/projectTools.ts index 5d5c08826..0ae0ed9df 100644 --- a/src/mcp/tools/projectTools.ts +++ b/src/mcp/tools/projectTools.ts @@ -12,8 +12,6 @@ import { UpdateProjectArgsSchema, } from '../types' import { DASHBOARD_LINK_PROPERTY, PROJECT_KEY_PROPERTY } from './commonSchemas' -import { MCPToolRegistry, MCPToolDefinition } from './registry' -import { IDevCycleApiClient } from '../api/interface' import { ToolHandler } from '../server' // Helper functions to generate project dashboard links @@ -144,32 +142,6 @@ const PROJECT_OUTPUT_SCHEMA = { required: ['result', 'dashboardLink'], } -// ============================================================================= -// TOOL REGISTRATION -// ============================================================================= - -/** - * Register all project tools with the provided registry - */ -export function registerProjectTools(registry: MCPToolRegistry): void { - // Combine the legacy tool definitions with their handlers to create full MCPToolDefinition objects - const toolDefinitions: MCPToolDefinition[] = projectToolDefinitions.map( - (toolDef) => ({ - name: toolDef.name, - description: toolDef.description || '', - inputSchema: toolDef.inputSchema, - outputSchema: toolDef.outputSchema, - handler: async (args: unknown, apiClient: IDevCycleApiClient) => { - // Adapt the legacy handler to work with the interface - const legacyHandler = projectToolHandlers[toolDef.name] - return await legacyHandler(args, apiClient as any) - }, - }), - ) - - registry.registerMany(toolDefinitions) -} - // ============================================================================= // TOOL DEFINITIONS // ============================================================================= diff --git a/src/mcp/tools/resultsTools.ts b/src/mcp/tools/resultsTools.ts index 6e5235cf6..3c95c5fc3 100644 --- a/src/mcp/tools/resultsTools.ts +++ b/src/mcp/tools/resultsTools.ts @@ -1,5 +1,5 @@ import { Tool } from '@modelcontextprotocol/sdk/types.js' -import { DevCycleApiClient, handleZodiosValidationErrors } from '../utils/api' +import { handleZodiosValidationErrors } from '../utils/api' import { fetchFeatureTotalEvaluations, fetchProjectTotalEvaluations, @@ -10,7 +10,6 @@ import { FeatureTotalEvaluationsQuerySchema, ProjectTotalEvaluationsQuerySchema, } from '../types' -import { ToolHandler } from '../server' import { DASHBOARD_LINK_PROPERTY, FEATURE_KEY_PROPERTY, @@ -19,6 +18,8 @@ import { PROJECT_DATA_POINT_SCHEMA, } from './commonSchemas' +import { ToolHandler } from '../server' + // Helper functions to generate dashboard links const generateFeatureAnalyticsDashboardLink = ( orgId: string, @@ -145,16 +146,13 @@ export const resultsToolDefinitions: Tool[] = [ ] export const resultsToolHandlers: Record = { - get_feature_total_evaluations: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + get_feature_total_evaluations: async (args: unknown, apiClient) => { const validatedArgs = GetFeatureTotalEvaluationsArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'getFeatureTotalEvaluations', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { const { featureKey, ...apiQueries } = validatedArgs return await handleZodiosValidationErrors( @@ -176,16 +174,13 @@ export const resultsToolHandlers: Record = { ), ) }, - get_project_total_evaluations: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + get_project_total_evaluations: async (args: unknown, apiClient) => { const validatedArgs = GetProjectTotalEvaluationsArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'getProjectTotalEvaluations', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => fetchProjectTotalEvaluations( diff --git a/src/mcp/tools/selfTargetingTools.ts b/src/mcp/tools/selfTargetingTools.ts index e4ae44ec0..9d315f0b7 100644 --- a/src/mcp/tools/selfTargetingTools.ts +++ b/src/mcp/tools/selfTargetingTools.ts @@ -1,5 +1,5 @@ import { Tool } from '@modelcontextprotocol/sdk/types.js' -import { DevCycleApiClient, handleZodiosValidationErrors } from '../utils/api' +import { handleZodiosValidationErrors } from '../utils/api' import { fetchUserProfile, updateUserProfile } from '../../api/userProfile' import { fetchProjectOverridesForUser, @@ -12,7 +12,6 @@ import { SetSelfTargetingOverrideArgsSchema, ClearSelfTargetingOverridesArgsSchema, } from '../types' -import { ToolHandler } from '../server' import { DASHBOARD_LINK_PROPERTY, MESSAGE_RESPONSE_SCHEMA, @@ -20,6 +19,7 @@ import { ENVIRONMENT_KEY_PROPERTY, VARIATION_KEY_PROPERTY, } from './commonSchemas' +import { ToolHandler } from '../server' // Helper functions to generate dashboard links const generateSelfTargetingDashboardLink = (orgId: string): string => { @@ -216,14 +216,11 @@ export const selfTargetingToolDefinitions: Tool[] = [ ] export const selfTargetingToolHandlers: Record = { - get_self_targeting_identity: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + get_self_targeting_identity: async (args: unknown, apiClient) => { return await apiClient.executeWithDashboardLink( 'getSelfTargetingIdentity', null, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => fetchUserProfile(authToken, projectKey), 'fetchUserProfile', @@ -232,16 +229,13 @@ export const selfTargetingToolHandlers: Record = { generateSelfTargetingDashboardLink, ) }, - update_self_targeting_identity: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + update_self_targeting_identity: async (args: unknown, apiClient) => { const validatedArgs = UpdateSelfTargetingIdentityArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'updateSelfTargetingIdentity', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => updateUserProfile(authToken, projectKey, { @@ -253,14 +247,11 @@ export const selfTargetingToolHandlers: Record = { generateSelfTargetingDashboardLink, ) }, - list_self_targeting_overrides: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + list_self_targeting_overrides: async (args: unknown, apiClient) => { return await apiClient.executeWithDashboardLink( 'listSelfTargetingOverrides', null, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => fetchProjectOverridesForUser(authToken, projectKey), 'fetchProjectOverridesForUser', @@ -269,16 +260,13 @@ export const selfTargetingToolHandlers: Record = { generateSelfTargetingDashboardLink, ) }, - set_self_targeting_override: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + set_self_targeting_override: async (args: unknown, apiClient) => { const validatedArgs = SetSelfTargetingOverrideArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'setSelfTargetingOverride', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { return await handleZodiosValidationErrors( () => updateOverride( @@ -298,14 +286,14 @@ export const selfTargetingToolHandlers: Record = { }, clear_feature_self_targeting_overrides: async ( args: unknown, - apiClient: DevCycleApiClient, + apiClient, ) => { const validatedArgs = ClearSelfTargetingOverridesArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( 'clearFeatureSelfTargetingOverrides', validatedArgs, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { await handleZodiosValidationErrors( () => deleteFeatureOverrides( @@ -324,14 +312,11 @@ export const selfTargetingToolHandlers: Record = { generateSelfTargetingDashboardLink, ) }, - clear_all_self_targeting_overrides: async ( - args: unknown, - apiClient: DevCycleApiClient, - ) => { + clear_all_self_targeting_overrides: async (args: unknown, apiClient) => { return await apiClient.executeWithDashboardLink( 'clearAllSelfTargetingOverrides', null, - async (authToken, projectKey) => { + async (authToken: string, projectKey: string) => { await handleZodiosValidationErrors( () => deleteAllProjectOverrides(authToken, projectKey), 'deleteAllProjectOverrides', diff --git a/src/mcp/tools/variableTools.ts b/src/mcp/tools/variableTools.ts index 16bcefdd0..5fde30132 100644 --- a/src/mcp/tools/variableTools.ts +++ b/src/mcp/tools/variableTools.ts @@ -17,8 +17,6 @@ import { MESSAGE_RESPONSE_SCHEMA, VARIABLE_KEY_PROPERTY, } from './commonSchemas' -import { MCPToolRegistry, MCPToolDefinition } from './registry' -import { IDevCycleApiClient } from '../api/interface' import { ToolHandler } from '../server' import { DevCycleApiClient } from '../utils/api' @@ -207,32 +205,6 @@ const VARIABLE_OBJECT_SCHEMA = { required: ['_id', 'key', 'name', 'type', 'createdAt', 'updatedAt'], } -// ============================================================================= -// TOOL REGISTRATION -// ============================================================================= - -/** - * Register all variable tools with the provided registry - */ -export function registerVariableTools(registry: MCPToolRegistry): void { - // Combine the legacy tool definitions with their handlers to create full MCPToolDefinition objects - const toolDefinitions: MCPToolDefinition[] = variableToolDefinitions.map( - (toolDef) => ({ - name: toolDef.name, - description: toolDef.description || '', - inputSchema: toolDef.inputSchema, - outputSchema: toolDef.outputSchema, - handler: async (args: unknown, apiClient: IDevCycleApiClient) => { - // Adapt the legacy handler to work with the interface - const legacyHandler = variableToolHandlers[toolDef.name] - return await legacyHandler(args, apiClient as any) - }, - }), - ) - - registry.registerMany(toolDefinitions) -} - // ============================================================================= // TOOL DEFINITIONS // ============================================================================= diff --git a/src/mcp/utils/api.ts b/src/mcp/utils/api.ts index 75d5888f7..eab0568bd 100644 --- a/src/mcp/utils/api.ts +++ b/src/mcp/utils/api.ts @@ -1,5 +1,6 @@ import { DevCycleAuth } from './auth' import { setMCPToolCommand } from './headers' +import { IDevCycleApiClient } from '../api/interface' /** * Utility function to handle Zodios validation errors by extracting response data @@ -79,7 +80,7 @@ function ensureError(error: unknown): Error { return new Error(String(error)) } -export class DevCycleApiClient { +export class DevCycleApiClient implements IDevCycleApiClient { constructor(private auth: DevCycleAuth) {} /** From 379fe19d2b61f16beb6e58716d0b9238d498d2d6 Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Mon, 28 Jul 2025 10:00:55 -0400 Subject: [PATCH 06/31] feat: starting CF Worker MCP setup --- .gitignore | 4 + mcp-worker/.gitignore | 30 + mcp-worker/.yarn/install-state.gz | Bin 0 -> 235015 bytes mcp-worker/README.md | 221 +++ mcp-worker/package.json | 27 + mcp-worker/src/index.ts | 19 + mcp-worker/tsconfig.json | 30 + mcp-worker/wrangler.toml | 45 + mcp-worker/yarn.lock | 2848 +++++++++++++++++++++++++++++ package.json | 6 +- src/index.ts | 23 +- src/mcp/worker/apiClient.ts | 171 ++ src/mcp/worker/auth.ts | 233 +++ src/mcp/worker/index.ts | 244 +++ src/mcp/worker/types.ts | 65 + tsconfig.json | 2 +- tsconfig.mcp.json | 20 + 17 files changed, 3985 insertions(+), 3 deletions(-) create mode 100644 mcp-worker/.gitignore create mode 100644 mcp-worker/.yarn/install-state.gz create mode 100644 mcp-worker/README.md create mode 100644 mcp-worker/package.json create mode 100644 mcp-worker/src/index.ts create mode 100644 mcp-worker/tsconfig.json create mode 100644 mcp-worker/wrangler.toml create mode 100644 mcp-worker/yarn.lock create mode 100644 src/mcp/worker/apiClient.ts create mode 100644 src/mcp/worker/auth.ts create mode 100644 src/mcp/worker/index.ts create mode 100644 src/mcp/worker/types.ts create mode 100644 tsconfig.mcp.json diff --git a/.gitignore b/.gitignore index 274ba2729..ef8526c56 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,7 @@ tmp .yarn/cache .yarn/install-state.gz tsconfig.tsbuildinfo + +# MCP Worker build outputs +mcp-worker/dist/ +mcp-worker/.wrangler/ diff --git a/mcp-worker/.gitignore b/mcp-worker/.gitignore new file mode 100644 index 000000000..6494d7c5d --- /dev/null +++ b/mcp-worker/.gitignore @@ -0,0 +1,30 @@ +# Build outputs +dist/ +.wrangler/ + +# Dependencies +node_modules/ + +# Environment files +.env +.env.local +.env.production +.env.development + +# Logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* + +# IDE +.vscode/ +.idea/ + +# OS +.DS_Store +Thumbs.db + +# Temporary files +*.tmp +*.temp \ No newline at end of file diff --git a/mcp-worker/.yarn/install-state.gz b/mcp-worker/.yarn/install-state.gz new file mode 100644 index 0000000000000000000000000000000000000000..1ec1600ca702c0555c70eb389df743c7a03b85d8 GIT binary patch literal 235015 zcmV(@K-Rw>iwFP!000006Rf>S&vjdp9)w-Sg&S-dnHiIB#DKJ;S+Sa`86cPd{~=nO z*VX^auj^m`qJR3IKfm|mzy0xV`ZquQ z{MWzw@fZ5P|N6&&{L^oL{hR*FAOHUE_~Ujfb-PlrxM)4LCJTz2;XZHp(2DmixjetS z$;v~=&(?ccv?X^O8NbUZJ+^Sg%`(}io~^nQyfUWlcJF1Jo_nRPu3!K7Pk!mY`uX%v zzy0-(KZ~FL>M#G|Kl<_KKjm+J{@1_#=`a7{Kl+=$`{VEZ^5;M0uYdff|I&Z@?|%NP z`uVT^xBuzi{q_I&H-G1E{_c-||96U>5#8&yRP^|?yq7h1N3e~}N?wn2DLu+PoAs=? zkD?|i$Vr_y?eLMaHs4LXnRj^Cdvw}Xg|ygfu_$_4Z&%Kob?>eB?e+JXHFHJiy>Y$G zDrbspWv|=!q)jcR8~e`Dy>6S&dAM#p-t6Zt%^IcChkZ2T#R_>8_p!RP@s*)-*OM;d z=4ju0S`MZBf3N??pVhy~AOGN=|BLwful~hv{`IeZ{CWMG{Mj$_uYdouU*=!`#ozm* zo{^=zvo>8d-^*l$c_z(gYm=#kDh1cA zJgZL0k|1wc9ez(P-psL5ALSqTj(`8J{Wm}LZ+`r<-+iU<=wJNocR%~*fA!N}{M|q1 z>%EF4vM#OHIuX3pt4wD6iO`-Vnu)b@cD*OEV?Cj;)lb*$t*f)GoyYP-U1O3>FRDl~_U+GxK^wGE1FR9s6R(WoVuY1&e z$7h zyl{!kudhEtR6`hcvi)eT-RDI5 z9odUBb9l#E!CTf@tk~gCmhil4xq2qP-hx*cleL6AUrvr?p7Hk9miwNa7bBV1O6}P5 zO%wh$GiTqjT17AH=*uFG6#SumHO4rTsV>i3mG7*xiio``tIl!Bow5Df>pzdWa&k;| zv)_4b>Pu$Xja9FPFTG9MgZs1LysnZc)0+{iv`)6%=4l-i6#!9a^If@g1qK4+JkYQ!JgnRK$wk8Ri*opr3`u8s8 zjPx-XV_lmzZ4I`w*YYLCXL^VAEPfIr|$jVUJmcF7rOuyd$-?62+glaw8PLJqV#LgRaq$J;Q^W;}+@9m~Tdo06CG^^iQ zAv!CsyvW&jY;sig9+@F4?&TwTQi9f@7QJgp<*Q;__VxPLCOt9FW8FO@(eKTgx2B?O z+nL+J2j}dIEpJuSb`!E2F)!9yb5oCuZksfbbFRD`kJ+vnhy9)B&ncI8(sO!wN0)BO z(XaRa_tad9g)Y$*5>XLe&D;}hvhP;PEvrApdGwNJr`9@k>v5!qvr)HfQXCpem+IKt zL(Qw0Po&c3mpVx-cb7lgr~6WUeSR^~^4ir|Av}p|NK^vt6nEC+uFYP%k53(wbJkkh zJLc$|>2sC^>($%Wms`!zi%lLUl(yk(G+FBME9baf-Li%J?AiJC{g3tLkoQ(e5t0?* z*(GeOF&XHD?zwwTGBIiR(GE<-M&34@ozlug|aEyZx%LomXwdr}P9xY_&zco|{-xdX@z9 z*%>7$rPoL#UyB;7`Mss;+!HsBT3OfPJNNZl_?~n#Q=;8b{;{m-lIrz!3l|c^Pq=Iu zd5lNrv+@(Y=}<8IU#t4@vzOA!-OKcKS(DhgyJoLBqp}ivJCU!A8XilF#*RNq z#(B`0k+0bGo!PoWJKxUCGiQgE;$1jLnq-~tTWA%knj`3n4?Q~XdAe-zT5=DW`J>?I zW^^^D)lBY`JW@|GJEr&ZVD2d%Ju{QX)Ap()>JHzVn{qbaP?L9p7G>}Cp1k=3?d3oG z)vv36_HX~?&+}jY_|JaVV*X!0`Qy6FuzL?hN%MMr(qpxb3);ftPiult_7;|A_wXZ! zW3Rro!m0c4+Lu&UU$c;>@5ZhDsIRrJyl#ESx$tb0Y}TtKelJBX`no$fscx~^TZXOy zr0K(F?Ks$C-n~mvQ?JQ=&Y~*jz3e?vv&AXXOU|lgd)$w?)zMSe^J(F@mwfC?-;TwM zUG7v8x=Wio`3IW+KeD=e>2rG4?0f)?+)nWJ)~A9(lPL-;#Sa^*hUsc#2KY^KFK&<|iqq3H z-iv(|NB;@XiBm^T%js4+j-n_!ZP%38EEd=G4(b@Oq2t8BA)Bx89XqjrGRAB)n|2P3 zugCjXG?5yRJEAZlX6LsxvJ!`i>_c{Xecc_0mH>t4Pf?>$w3c@6y=4ztsY}+@VpX>4B? zd+U}z(K@BwTSKnf*VnJZX{1YTcS?0VS?f|R)XI8db8zi_-Pfe$)2(t}Bsupuhstui z<>cG;srCBK)=WDnKCuI|s29zl%|v~f=Y?O9g6oo+4?ykYwpiPhUP%hd}-{QCO*x?B?POm~B_=^&PK zd2YPfrguHss=$Mk&_T?dzT3Bw#%;c+7Pfs5B3kApq4lmb`CjoB9_mw86h)frZtio> zo`+I=5r4gZ&arn`?7b0_*nTzp9Mz=amFJDn+@1owrGbV`wM!J0Wb=MK*^(MLLqxi7 z)K>0PUN6sKQNL((x>EcAnRz&Qw>wzTuhA`8aour#C3~$|&zQjmc8!!i8*9CVnvCD9 z7Bb(#CT;g_3F{@>xZ(WI3Nhr zyXR!;;?XqTz#L-R%g}BrlnTmoG*8aO2FXL7Y2<{qjcuP7wm#)DULIbIqvWl;b9MXa ze6!y5UL}XsQopVr9vw$Tf3MDw0@*z=dXDd0fL_ME8x)`q8eTBSR!U1B$g^|$fd;4R zeh%}<^OM#UzG#g)C0`D}d?(K10aPHo`<=b(=>7Wq(zzeD^wE{m?AR2hRtKAwJ6TwR zl}m9G1@^gQ&oq~9sdLulyPx1~dE94me7M#I7I8TEp*5XKaJ^F}hPLPT{Ub=P ztBgKLK5NroT9V#Kw@va=)2`Q*MeE$TCYcY^ht)y#+~##Wh{INNkT&a0AI})i9w)0f z6sjq!T6y6;vA1Gc><d(UmEud~y9+)x?B{gB5#d z+NW=|TIVgZzH^hC9@mId$+=Z-BZp-vz60RAeU98Gv9u)SCR%C~LPKa#*XtF%LgR!B z8o00Tf1kzkF737F?v6{RxAcal15HQRIh*E+Gqa(z#>L(42J?9A@EUt_PuY@vdTEb> zo-G+Ey!1uuKqTUH>0O?vxZ4)UpZj(Fz-!LpwF~8xiC!O0VJC39Xw5N}PZgR0hZ{sGA(ec! zN~!d{q=Ogl>+4qo6QrM0QhlA=yEgigw@MuXl+m*nlqb0;bovR(255J@Y54Xz7x#Yp z3`zE`1>%_92CXlP_3RB|cx+8P-*2XNrx0(Pt`+BIUmYnSw>l&a?zl6$XOZu27` zi~>TVp-i)RT~|wWnO~*%xvWh@oAtgpI=ZtN!mfGw_Pyolq`jypqmH_u<@vh*Iu3a0 z1?ky+DEs!wN2=CWYacq;_Rr{P-Oy?0kJn^(Q=Y22xY>Gjx^UA?Uf}k&SRk$LC zqNYXrgnK?#bDoqt-8#Illf^vOOk-mAb0r5A zab9JUm!c?^E33UIlf}4C(Kwcq@5un+3VbcB@7f8ffcCt+DFi-0b&*M;!iy)D>`!q2 zp<$qfU6CBb+y;|ZU{kk$^e3~It#dzb?9d}+T`{ku;%8$KhHd?DW;1FlzJc_snMEw#9_SuOPEB$uq#5J;NV%x#%6yya32n$qAI=EW59;e3dSmv4 zJ#P=kOKe+L)){H<6{PD(@#c|i?S9=~*ALJApfgQoeMjDM%~pTA_FAK5yLrVEDxCVu zA>z1>@(iD&8Zw#PgMtZE^4;s|y}d)db=~lyl|an*Uhmk`8*is>0_?ZH?;mM;=X=ER z_)}_;JfFlN(0Z28j?4F=Gx=;rUK+GRDx5z%mjtMZGNR&#YrDNp?Nw7N(?0;^K9TFa zQj(S-sW&ncR(CI&=iZ^n^)|X-FH=-rf=NUQffiebs)RS z!;{$Wcgy>V zP+*^+JWHeBhIGhp9M%l(1LcDqfocK`WM~?_HP{9q#BMhVGx6F`&h1Rz?R`d6zQ@nA z?jqniy!LLOXKNclBJ?V#ARfEE_TfTTZbdAcYhge6AS#E2b){-h?ILP}PKxdZpjCHW z-#Gbzvc9CXDdYHh;0iU!zP|s`C9a8HiHFRylORH}eqJ3^pa)jarHu~dDaq^8VK2@w ziOG{hXIqm zg01c*^p9Y^E25uw>2gM0Z`&`?$=Qn}H^5Ze4EmU^LyYVlW_ahmUq3vfIi9>~VH;nv zlkT&Fw#@OBKm&-~rDm_#F80?sn*b~xF~C^UoR(bicDc)tQ40}g-Mx}j1H?gzA70P$ z312_t#$R8*>U!zefGSM8XWQKr8`=hkmcP0oPu;4AhhKN~gJADIfkoq}#e#!nTgLKb zQVZ(g+iQn-9>U2>Ax|U#peyxbu#oTRKHt~R>vCTA7o+`_ayzfPs|)T|KwzIaUCYPcqx&e|xxogT(Ix>TZ3`kP&=<7#JD2#r zyYt!9rwTnc%IGL+LjL;w-R-Y?iSk*h=8EHLIL_?-fM&_^Z7FN-i;kP116rWd(H=+T z$vux>)J>?LWiBs>Fy-w|OU=5zSj-~cT_Ry{5mCouz4ASNg2kEn#J#Y=0nCcYQzX^- zh=7)5TJ|CMc22s%m{7UFr!a(#EBsu}0zIcd{*xuE-u9GS%h4FU!+?Z1Pmor_`4H~+ z>-(=~r${#xOTgh?S+3z;db;JE^2ZvVs%AwT^FEb+KbW({?Wm8m)HOG{li*X8QjoFB zWEA9KsNkn{&V~6_h{FuuJr^jo@I{ax-_G@A)qebGWx`9LV!P)sc{2k3OWWwf&Ur zqqAezna5PYrLjq$IqFp{Sv=> zcx}-06(FQkCE{YSg`M%&d>BSQetX*Ax!=13GKaKrx{khgHK!hdeOPv37J0KkqNYC= z(kFV%1r^1$j4Zk=akg+f97o#M(PBEliHzoY`T_=~v&_kv!)s2>rH*y`eO>=N-UXjv zKs5fyqPFcQ9(H8p2Cn()rFC-7Tiajy zX#hqxW&71U%TgGo{Z+kOgjV?b^UD`Rj|wlH>tiS=b#RA)*R#XNNs&V9GP%rB#Up4z zF#(?re6qc1W0UIPtQgZXJEm0mJxC?8?v>-f)p@~S+$PwSE`QCxpJhzI8$O-aCHFSd zZ4Lw-X2x}trW4lTZ9;{LbjL+{0a!ga?I7O<79k__Q8!4LhHrLVCVUrlFGvET_&xXy zS)l7$`n`UYVO6vxXhdR3ziG*eTXge`3{eQ&KLyX`bKkT3#RE?{i=?=s1AZNLE_0X= z@6+%x_8edrt3RS}C3Xg^h)gR2yR{N>1_a8qTWAF~X2$ab%MDZ1mfst1?4CmM2d3idQJ96(Ng<{4N3wtX^ zRK?|ZT)k38Ajegj&2S`=3bZRP&Z%N(KYTe#!{GY*{*RScn!a^{OiywbnpIti7VMht zfhtBuho+%{K|TLKO{NHg8&fx^;ZvA<-*XNdqvq#Ljqa!SX;wpth{ED7Zna%DzP?}o z)v^^Ttb7O&Slf)Y9F2WHGV&O)62W+MctOIxQQ7#m*#-Lm?rj%8 z!%C8@-7Cqfy6M(xU!*R2zutf7z8whWsHhN_M{}(x(DAYP&PPM?IHrO{F2S5Y=wUR@ zvwNTfm9s_?V#CXe;0h787dXDfQCPVi&79&Tz?*P_4@F0OkDpK1#*(+*uYw=izUf8gt{*^6BYjg3KrMG6HGfhU6asR$$(I(nwO*DAps@2s6-S~ zE!Wren`E!vW8n_BSs6&iXa%kqC)7OpZhdqXqp=gojL=0FP^P6 za=U`SD9XUg@4x$+*X`ETkh=2T%ez3&6NUGn!*knm;prE&_e_s-?LUD#m>vTUpsjb! zjCTYi<)vCS0qGqdT^xJvk%^0KWEP;S8oY}u{MH2~!kkAPdu^yZf{d51lYr3ANQTu! zuhjzGUqxHGq!;%M?L;A{sCD&W_dC&)3`l7x8F~U)vnIt(nigvFTX9 z$8HbS za*}f0#JwlhP3O;rB3uD15}f4p`Z&%whTb2%0>Z=K?RyQj*#&wED9Wn-K>hRM&$52; z;~)RdmYwyBKRWO$Q|(^4@aF)ASn$)Lql#X;O2!)1#f2mY;bu6Wt{Vz|q|>eID3#Iq zP|V6h%k^>`^=eX8mgG8kRn;Xx2A9+1THQF&1`MxD% zx~tzk2P!1ESqL}Qa=*^mw(?ObAzi8FfV(UzoV3i=MGy)Ub{1q68e|eN_vAasZ5zEC z&U3NPqw?3NGVZ=O{^Fn(sXtIs{P^?!>60G!d$<38_~$?WtDk=S!~W^t_%D85{@ecX zU;h5n-~R+_?~lsTgRW*Dk4q0Fl*XZ*p>=!lv=i);eHgKMMlmdo6CJ5HPjF`PE0V;K zc{$dIxKnB06l4V=9}yg^!QKG`Ri2EUb1IV%#`L|No_0*mDL-h*5G)ikB68#cHSCX{ z^#E+LT*-1P{A4}1esIaqKKmTl3DyKCLV_M3D z6G+4))9tWyh#Um3p%AJ4Y7xRQLK+?a$rWegjod&_L+E;!gWOIBLa1>NpZ?G2_jXd0=d;9;RR=ucRL3r$X=$c4iL zCN%U=NSTDJVG5}McOG&MABiXJ9wtvD0zi`ezAi_A`13gdA4am&yeCWu=SY7fi4vOg zEPwvV*a`tfb`9r$BF7AO-3Dn9vtgI)$@OA<@1qg`kDUj`)^iaJvNzJD_!06v`FlI4 zFx(o%mYdOu`kts|m#~e9l{agO%SVf#>`4PPDfho{tOzHa9jy=6zY=_L-@D{b-HWjK5LtxVQL@n;XI7qs%kH7)!u zA}rC|keRGQWZR*N*=km?NA1jN&T=|?0SCnQY(yFrAf-O{>-RU2-gq(=trc*6iCBrW z*5qU1o;^65XpJD}<^bA-Gz~`Q3~%sgX(-!MmcMnRk#MUA*<;Ol)pN~W2$LeC7lIA0 zJ0{EQdpYUb>aZyzfT^!1{6J)EqZ*F~;?+6(mhxap7?f&=QiW3jxl?ta;U9bCewYA7 z`IWmmVC^QUcd8M|`W8}1Q7_d;2r6;0Zg^n*W08P75;Qcw`2%p+k3Z|b z`sr`W@n8J>k1oeGM);`XuDPG>2(V@(MZE&>5JRm1qrgS-7BV|K z)kq(LKN(b70fAjIfrk6jpx%3#-nySceKC4J&p+@=|M+`<<^QU``A$faFn7AR>k)jZ zR+=MV2d@bY?7LFQI0b?)L~HiRu$hVhCk{P`Zp5ZC?m)6UAOs9vaG}+b_rYVC5WcpS z!U-=3Ioxl3UnV&OvWbZ;;8k&uJ)92AM_qmO;L_E6l@j=2=j63fG?4?K_EQjeO!6UgXqpygDT`*(L_qZJqK;!I0e$JBcU_Y z(1Sn|2$f@>yWDLqy%x6qo;7q+WZNx!`awq}UWA#84wB0Wz%}l%B|SmeL$=?6i;Ug? zgWrqlqYi`$b#38+W4scflk&Thy*H#`vmQ#Yqy0`TNP;}{>tpW0$F|=i2+7_j;Os>A zrps>}IR*n2@X4lUmVNqF1T62=u(H@LfH!w6+V7GNJex_s{kp_|rQ zI(O~9SEBZQTg*R^Gsh4~1E*9!q}ZFeUBFylm)ZBD&X3bwz8bOuL_k3f1(p__Jv8`8 z*uM7Q|3kPEazTK@)VwQFi1(Yq6+-;U)Al&(hPmy%${VptOc1laBPTc1oB0&Z_pjUJ zL`wi8Rs(jIk58i2&h<#-cgJ;6J?ml>sKl{zP)H0^TZ9@s?mRlOATUAhVy?aJDIemK z7h?GCxH`x$YMP5MfwvgBSpL20uChi5G)&n&FoY>$R-rQ3&;cUb9@)(A9p?gQUuP7z zwLTdRvIE9rUzaxUFhtPY6#~1N^gX+`qPw?F5?Sg*f?~2n{j9Io4+7auLWEfoQF6DY zp#X%!-44J?a3FWXJ^_Iq>825#b0H6=?LLvNZoCo6vjiGL0HMaYw=O&k0)kv}RF!4h zR>M<%Yn`vx4?7}fAy?QFAs0m$V()>x6c9%F2r#(v-U&tI@Opmd5=_ytaStEfn@z-f z8myOI-^gdUZy*c-JVWmM>AJ5uWPUduzRdTkFD6*967xcYZ@Gry*GAL@!!Mp9KZ z$u`Kkpq}`v)lEvI4^>&3EUgh0e64jX8Jab zHbrZ5fKQ!Wj>TQb^mWcsXzH2!b91I%ilDvd^C&wJIP8Dz|k9*dXNIJTH9i zXHp6#lE~b7P&0(-%+vcRQCn;as0qlYKIq=Qzl)Nwng!kREZ!o>!i8w5KvO{Hqqrkf zhzZ^PJxupt7dS{m4J8EgV(I>L5miWIv2FIk&xm&#Fwe>d!8*%Lx2W~LJ+yv z=p%N2v5`er3va{Adl%4{yElJ*ekHWf$YVg+;Q2OmztsZevO@78v^>}Oox!rVSW+!N zn+*WbNiAfS!eb0Ov{S@OP~=d13ep=#Up4aoiI`|EIsv{82=)C5QUf-$dmkR+oa;n} zkxZzlalhliViG=&9J=rD4l!eUb1L6Fnl1d21++d5DWGh3py+qmY^)V4&JMJ2M*tZE z8Sv=XxxaU90So_7vTJCye)4jMm(GfXxemBw%o{-7!hu6%2~sN=aS|6w!N!*%Xcra% zV|VZu@C0I{0iqWnLZu5^%Mm(py?wQ#`h-7`&K&V*(TCI+@8?Oaf)6FWRqhcTp zW>Q5Hdw?`t;LMQ3Rml8Fscp!xLeIDuT61C@gd2QhsUWolQwZu^9BD^@!Y_E|`0M?j z?xA+%%T*sk)GO>6E(3SH<|4xkFHrjGVdq|v7szv>i+L8j96`s#5_i404TlSiDG07Z z@T*3=!i<;ohY=AeR>#4`25b@$setq=S~A!4f)V1sH>6U zYHpGj(%-y!VTU*YKHmZofuuPmH#wlhc*MHy2MdNy<}q}66VMiX4>RVogZC-@g&A}D zae5>1rs+g$iRQG7h#RxJz={meo3+6GSdrXhpA}NJe;wnLjYI zi{|m)^+5eSOl?;ZQbkSZ#JAde&w%G3+tkqcA*KI>`pMPSfu`D9F= zr(Fhn?9yI~z^KDHx88Y(2>d?vj5ZNG{+70_H?Y=(D-}{{%wy`0WRy1M{{T14N!ckd z|HIJ>m?s{eS%_+m&5Pdo*rnm7xSGgtY;fkvh8!8%JCF95)Vce6{1)PWIJNEuYbV%4 zcF}`-5gJChzJhNyeSno~TNgA#>r=I6JaoHs&(<+m&;-e^j3~o{aYxnIKS3BET==4) z7v*>TV0;`7^zU8kyEL5m=zWN=axidqp6d=w*zq@*BLxYIc-})#u=3x1;tT3m#gPWh zCJmOJI@LrKVNN7A;@#!YVXW=QkvRDhU@^PXmgYaS1KD*(-n3aQ3TOau>l1)xmJOsdv%%1@N zOljnWf<2l|RJVoFp0UnLWndC;LaYHZq`C=b)kR?@?MMQ*^+bbQ${&UdT>ixAp++EL z%|pn^+^-&T0Ovi3I}rM9q4B+I3&-YJYH&=94avjW&Rka((?%HZAfU>cG2Q~RM7{Pc zHd0c)gmGp9xpJLZ>(g)n27;?P5>qN+2)S?Y6@4KX>Zw(fr1CamJCEIY;hnlV8w?<6hdGyUwdml1b(v<*diD^kdzRY z`@D%2IWVj*%mv-ZtS&>+m~4ha4I|tH?c47*pg-ig|M3rg{?pIu*NJJmfB*jvr3af$ zZhD4DHe`iKyiSb&z#;SoR`nZTA(8N3Z}1NJD6*|?1M1&t2oy$SDeBHEHk`_s0g3Tt z@Y5oH`>NkXNXdB{a2*WRwEjR#{NvC6>ZhOmJOAY`e*6>gl>gx$fAkkKxlezW++PPH zi=YC^Yov3MeV*jPn!z_vlam~9I$aW=Rp^mS;CjS7ny!6^fk&QtkSI1b0BiL^$0Xel zpgfr5=^@C`_SX)D17<@-5ac`!dk9qSm@%S<*tfDA+WraR?Q9^ZTM|m)L3oiRW^rJM zk{r-Y&qnUu;UJZL9GW7HwJ|ZG6q5oW7VxDwOE|tyNN!_DmCwlp{9kFyaB$NgEazdO zaORo?Q(q0?e6(N(!y&OG2pTRu_u3AI{6de8@{AF|%t`yns?-TOY>a07NUL7wv5dujLP zgGdv^6+xSg$e#cTb`d@qWKXq;U!Lz3+WctmefEu$XUVx#LC{hw-7ECOKER1Y!iw;_ zLCyKNr2Ink4jf<+vfPm7*k^+3KEDfjKE_cEB+d9pqA73gGjJ{9!SE|oAw`!dAB6IKNi>J-6Kiz;6t2k$u1 zu-QAyAs>_EsF9_RJZ-%e7&v#1Ld+AG(GH6eTj4CkbQ|b>L1ai@Bn%Jqa|p2nQTPTr zB{IW2xA+>XD9jhwjcLdjda4g0jeM@b+kt@&y3RZ~m|l)4G$9-xcE40r#G%t2Bw7G0 z%Y`w3GvD7l|Ai6ZVs*F6s^x{vAZ_IYf^c~1q%GpE4p@xn1GWe8xD&6xGKxe)l! z755>UtAfud)pLUm22$B`%+r`mFI}ZyU%$5<-^=ZIR*sbb9#jhfTSVnZ znp~qtwl9pdD_{2+626{pbln%)uI4&?WP{|y5TrGaFu?U|t{!4Z3=@YjlLGiNBKWf| z%|)y{ENCVJ(~XcZN{JLi-!!IKqLXP}1iw3oVhn7{LbCfuW-5LR{m#2V&>3L{`-44c z@E_aj586R~`_s=b@bSk#s-OS#Tc`lx1o=n*;io^#e_KEP>F+(yZiFvzxdl<_}vfiJO9=1f9JQq@n8M)*FXP7|LoVl`o+Kd@z4JDcmMVS z{Q5um?N7h|Yyb8C>#zN+`mcY}>A!7U+F$(RKaRSAnyuf1`-vR|K-mAu+WYQqwj<|t zAL4(C<2W&pd=Ab9SR{+AV&!gFB+D9Gni1wqV&v|F#nuEi(138V4=e+xXP~3*{=M(s zWYzPmHK~?>v6WiD&D{dGg7L7iCq8DJ_$y(EULiR`!)eLW80|Ob2NH}fz8yUYyj9mB zeXZ7k&a8(IkN*8Q;Z@%>B_kkt5^};p7=une=l@Y|0c1C&kruJ%28 zU}c`VxlVG72Qqmp=p_KYQhazh_j(3c@JXxO6V$;$H-^P-WFd@pLWNnWJP6hl66$4GExm9~Qnt$F z(6%6V><3)2-gQ>IuKlM!|M8cqIOOF9#`IX-ZI&=+QhzH8W8&4UoeZtZHIALJVn^0WHm}8 z{H+Y1UV1D7P|R1w4*tR%(iI#1?-1q{EYW+lyL_}Y2AeX=wRtF35sN-lF6TT@KYW<| zo~65ZFQhBlq|G>bT^c8KAot_qHnd+pdG*-=3Ib`SmJ{{}>HpiHmwZ>);5Q@++oJga z@Vbx-GnXp!UE?d01)D0m_sNvUGnu^-5mm|#y^;Ocd*tCrdt)x0%<#^%g*NgM<)r?w z@7gi@zIkwiZTpT8**k!e02aOOf$oQO=`irGBg(!w6RYz6oTcYUAv99RI_)}`4riUJ zlPzC77EA(Lo=o5r7pZbAk3-7>fN_ZO_FjKN+AOAsC!$T zGMOlnVSf;{aM^PFKALI_7}X?4kK@VK(JA(8%(AAfPKlN{^|oGQ=*uowb4D<4`~H1E zG*NR8x7nwKFn!(8t!;wdY#+-T({ZP{Cr00!XZlmCyCn2;enB&!)H3N>auTg(tnyhE zn$pvRMRiL}X~nng?I^BXe}^zp-qmG-8!EKN4Cg=zXFU(r5n@A~2f?z}1Hq?bDhU_p zl($mYSf=M?uuHhF(_Bd=w6(O1xwFE^gXA*q;2bfz$5K(IR{Hrw$I+Pk?FMo@c}HF? zx5-)E+N>^(hhUjkF^!*wF@qE3@MbWJ?vHO{)43)&MNGx45q32IH1`g+or9z!f1ZlK z$@;kgO|gGhz|=JUr=xCf$bg|msXJ<((mmSdOv=3r6om3S9Nk7=5cclfHaFC*{1{j62$@(7gNe_xJAAHd?U;y7`RzV@`VR+A9=A&2@xM zy9bvC0Za;HQd`e)Sg)?tb*{Zeb%0U?&e$@Xd56%sZ?*M7No8%+>xqjC7%2J3@15zm zzRSFMFB3o(1xFXD(U^|=nxrvNcD1obneAcWq}Mgh>ScJOZ*ZX9?UX?wvpiYhR#=(G z;VbvE?5xWR0zKHoO>_~TM|{4KSzoVg9!Lxjb2RmOy7XG-RCb zq4cs#(w7!nb&({AHlgrwFRfS-8On9g42=iyzUv_a?vc|E(XV#C-{{xEwqg0wu04fN zsp{>>-?|s>Fu^o7Qx|`8bZ=M>n+JYfGC~=SG8caLewJJYuZcMJx^(zeHoDwo1q zMrM^>O$Q#m&mV=Q2DjH23GE7Hx%y^BUYad)#fUjs>P^ZZCYOOh@$LZ74yYjqZF)`~F%3 z^#l!{YgN188m%6~OkbuuGNJxppL*5M# zEdqn=%{N+CmRy@uQ~Er1zMF-L&AAN|iAq;)E8yLh zYNL+VS%p;L<+RfeB^<7jo}8PG=t()C)zFp6ZpC~!TJZO0xo6?`2-W0Dhiqk(?8E4e zQvTvPH9lu#XSw@eDHe*}bP3@(bD+t`+V61Y*&d-*v#fQo*FQZs)uo8ACQ)6j&e^qB zUJ_Ct)^U&C>zZnFyj4xj3wAsShlo?xZ{IW45GGHlahllWa}B!$T?}00DG)Y5hHV1N zE8rE4E*MPkLt5Ko?lb6J%9BaYc53g)8Ep4Gci-N5I5Pp{C(Vq^=lFByP2GP8-mBRQK(-Wqr=x$X0{G)zsun~0X=!j9;ZdLG89d8 z5PYn<<~%Y(oX)@SlbqqJZ#-^CpBQ*mxNx-*@Uoe;%+jyd>!06W6~Njh4;zhh+b9JI zt*EkPN-<=41s2ssKb}$ruS+gw&z(!}*}>qJTLn>q(vt3q7Z{3OYkg~Fnv1jbT_3m; zYPQ~a&UX|SgOfRcb0EJOV6EN3DQ!GQF$@cnI|I!=nR4}l@SyFUhZh$?$e6c3f6R?l z)4cUH_YyGujZOp=p`On+Dib|ese@#m*7Eu9|2(DK0{_}>f7jeI=_QRb57+UwnT=1D z)=Nr{cI|pih7uBEyA4FYCr$j?hV#xCZ_ccXcv>CKDgD?!&BuZilD2KAXb`9S{P#Z~ z-E6*?xF>tB#3*FUOEni3L(#K|oHSglc-T70<3h*ydL7(j)RM=3UxTpoB8HQbX-c@Q zR{8_3bNwj&(D7!had|D*&$+XH$1p^u>AgKC>d>6WZB9>@GZ4efEu(E5fOlUsGHK{h zPT6K-W5F>ch~l@AtL=MoX!zln&S(OlUTZE2Xo3QbA|{oj?`90^&{_@!Tv?-hKmSu4t_K}6ovA9wj7{E?I(EfB!eYgj zVb5xc5;9uM$>O-8FWc_fboXg{tg{jB)=tNGrX;2$VMFe-#-tO}atgwjR+2XD=dt2O z07O8$zh`XOG(0;Q??r_lGcB?2aSm9Fsg+fbchi(!3gc5a#m)C-0XRykPx4#w0!D@I zP@ZHJ=%acC-#;o_@Gi;&fL31H@_jACzj0A)Gg&<4D7%hT$z|V_9U|i>d$m$~DQ&21 z@C-HYMb+I0;_+Luo1g>ODYu+VPk-AoEdDLU=Lo2Mv*kf4;vMtr)w^ zdTe=4j6E)no7v5{2z%XkN{{SCk%8Iz0fHw}y@pEZ4o~Zo zO9f0HTFWJ!(aQR67QNOQdwKT-6+?#Sgxti~7E5lkD}}#ZGkrV=&THa>mrU zU;{CYqGrf%wtK}1w(r>h4Cg7jXyBrMGCCsJPu6$Z8&@@$WNR*T$7j_`y|+orf&aX& z&tuWrrFLC!H+t@b~SAET>qM*n>Nmo{GkOCEk#<0VyURlAApf(OtXYbggaXW-_Q z6B)PT6M3hdQ>Yq@d7aQAyd+LXA#x9LgNtoa%`2YN{s!(sEfXTjcg7Hnyj!q>k(Z2a zS8am3V_a?>ZD*9&F&v@jrl}VT5n8N$Dh#WOZS#rOoFC59JIjJ+NbI42F%AxW;_)(dB$l795A7b&*%TV1jUqBRw1VKl(*?fvk=L8NY%oU zD`m{n%{tbV!Qk2))`gj6g=JFLW$(d!kT<|(NqCGe1UERXr}aJisu=$I;eEYJ|K9O# z?*#2L1*Ru0pjo(wC&cnHvt=8zp6PY#%c5*hyn~>XIqHwuDA^4rq^-?KL#~o_;%$e; z)my)3mK}Xc4Q@HJ^#iw2`}g?+U$XwdgE#IZ_{s))H{udj%5s{01zER-k|?^Z(=pTi z-eCqBdCBM#(G%Pi5hDOkExQX2L(FC~@8EfW`j0ffjL=)Ug(C#vu^F-S z`GGZZ8n=evX zdndLP)(JS1DTR!6N(e@lOV_cIm?-z$SDF3%`5{e!$cvGJXYJ0;O$HlY{wG$?ycFeM z0Rse1cJx9tY~1-!)%6UPREh~&Zlzh=LmWBXDBO06NF>HBz{l!{CqSulm6VZ334fL66Wbb0CGrw!!&BlAshf(!0WHo2m=%cQ=Cynj5 zbLsnN?jtw&4Yx7}u*jPwl`n1x{;vuftdZ;3wWY|Y2jX9zz2h+3yHF-%LY@~Ib88## z=kJWvNRH=?%Pk0FH68DfRbC$ zDG?s?+RM0Y_ek6|JqNhIz%@@$an;JTx@B!G;W%haC69TnP183C{d|6#gPhBC09)8l zSk{%r*;AAY47d7eymwQU$~@9F;*$CSTi8{*?tJ>1&5mQw7_v*-^KK5~0`8O9F6-5$ zA(f@R6X2(H@ZC(+CWF}0^1x_=n(a|)jJ;_EoNISND|?@vv8UW7eo>4Brmu0WiCWRh zC0e3#H!tjDX+2rayY?B}Q?7OrJZfaE0O08yJ zvl{2f%g=^dGY1D;UzbI91O-|Sq6)jXqBVYqR8F2lUT>f0jht8TqCiTkk4wPppZC|~ z%#D@>L&BT;6qtxO6LYp~5Y;hhaZTtg+QzoFf}BPf5#@Hy3%mQ$eHRpT$0tcJlOoU= zBYDd)?SbcGJdSOOZ;nJ5e7~Q6iZDTe&@?KDj!Ojkc+6-Xr}Vk5y~lg!$G{tj^PKvM zv*g9mWMeglAM6m$hrR`UQ3NR1t`_$L-poOoPgoTbC*5$vKF>eX`#w7b03yy=-wR?S z`-Qz`gu>5ib#E?cfNug^B5x-`#){+;6OTIMx7i8@eLZQDpAH9)uD6b*U?n>i2>i#b z2^*aF&WI$;owE(Ut>Ap@y}q<6fym{f7+KXycZ_!vwTOvm*XWwtZqyLZMK!}&sI;AZ zUI;9MMseRt%KLpjbMn_y*@PVTi6Mqu$M^j^JfNW+sa7zC<>uaZZbUyE)FvVjn@owK z?uo2>8T*PdsYot9fxE@6Bn|6jo8a@z$pZ_$oOp2cJptJ~ws@sZKN{Kv|9pPVPzl)! z3h{-`&rPv#4lRKOc&w;ad}R`hc909aLmxmDi(3{#94zRao>pO24QG95tq~Lt?J_Oe7?Uo?onRHjH*gz<~(q2S!eUjJ0;i51Dt7Z=Y@RkYL9N;Kl6ra(R+L2&$nvzd+v9$C?L>kFA;;(=j>UYiaZzR z{>fjWu})eS$++6tJ=WoZ#$>``y0`^MlR88YD z<@@~py^^}cHhFUO4^z|1E7x%kD97(Mg zq|-cn&+YG&dSldb-#{tyho~+$UHb3O&$P`Qb=3tzioR$P?y zIW#Cfm)>-9>+pd*TDI3+dMabNbGQ47eJ6S9v@E;yGHoqk5jYihZAiZcY`Q1J+G0BU znt83!jY1%~RDK4u`K|dqczEs1=%@Epc5Z{^6vwCJ30#|eDQEATed;LTOB3{Fq!_G; zVODP+@6}=IWsq%?%7Wswe8hmLWt>Mxs5KQ8(`o}q$oKgzM@8WEWLxi&xNAzx-E>TKW~uy_(9e!0ISvK+@;QbZ+GoMo4|N- z<^4SW=isoi4dgd3Mj(8auAc?My=Qd^+LF_*_Q^+$#zyt_3KsR84q>6~Bv{B{fpVb} zXm?pu4>w5ZG6!B~Q#7WrKr7YkxNJVppA|Y5AAJxf%K%ew9q{DMRfN|LuUqhyu9k0& zweK~BanB#yI}_6a3W>Pt$hHN}sPumaZsdziJn4AUNrjPs7HTUK$ z)Pjb0Kpt=<81;RRMUO<9&XL!N1xGX)JWtX9EM@6_`W1^LWr=QDuy-G9C6)3vz^sMDLrbET_>y0}JJ-#V-FHh{|Ep%`WEgNuF@*L&D-q-_E3fJPDF)>>+ zwY({7@h~{Ym#2fX`yKj9ic7+nIL&PPK0hLqIE}O6O=Uf2wcgL`@!=kg zBDFeI^DG0j}{QUdp%(4%kmQF`fM=w3bgf>3G zT=&KZR0h)3Tn$%tpOSg%2B%QQfx=L@R9YN{>^!@4$?>Cu04O{Ais(*ms~oZ+%Y~Mu zBfbaYl0@FSsS|7P>rlSqbldWX37xWnFow;eqp>g=2x%bsjT3>xaobMHgtyd9F2xd( zP&@oA>&Z%V>Xv&7n4U%q0UAz)_xbr?F%KhW2(TQ7L4-hfr}1iyZ0LTWsCoDO9S(NMV9B3gXZBm({&QJ3a*e5gQ>;3PG7K)E;e3xU461_je{)8syk|*L?mC&N_NL9hry|8 z$xlm5G2RW|oqm^(N8#>%t$^YhbM^v70{Bfxl=u-yqR=QfyWl8C%w z6u7&j;`)*YV#t?F?Ki;ny}3#<)jKJ;<6u6w0dx}}+pwNWfclhu@D$6KexX`@A1n?H zX+rrubaLK5g?ixajjyne(aRYGCCC;WqpH({F6%6%a94&fJjkN4Rl=j$o&Hy{Gnu>! zwv^dm7o2W`6>fi_>*4y{k&b=0E1dL&izxO$t+)^6E($K!JNqNQqt_8L5K?YC+GZ8* z_PLY^L{G!JfM$Ssf64Lu_A7~SQ;Tq&3_L6d!vkQ@1JR~{?C8?4}bjn|NIxfX@tjNj^ZpR9+`vP{9O1ZSDBs{c zG(rsi%ICh(=A~b)9aWE3B97C_XjK&5M52-Zna%iL{c-*APk%VS{QDoDs~^Am%~!a~ zkb248o7}CBc6qkUWw$OWL$Hrm;!opL8VG;w7_Y?8w8;satjaY4!o#_0sI7DBvUBe! zhFrRJ(=eF5*8I54OKWcL@qIRVrJWu|(xhfdirB=Z{5379GgGG380myw8WLO(bK~mN z)MKZjsKS4-F{;>6GJ=t%8MP*xkNSCI%`?tW&=2!6TB4ZQ;`40y`2MkNKlsU7rLM;k z7I;HFrgPyNq!+-MuXxY3N?peQSwFv1p9ypiI@e|MCvui90!K00Jo`GF=Qjlu(F+e= z>Z-$JH2t295>xIkUG0*E&gHU|WKmqytJR}621X+DB4?%N0h?a#XujK6?F{FUvw-^C z9nxD1uUL`jX1Ux6a&fDP9fMknZ~(t@{iua*7PBY z!I1+jIE*o*+bCumv@`|4V6v$`-LG>bEDlf5#7L(K`srEWR^&PZ?TH zL5{$-plbzvyb35P{%DVb{7#$`lg&LlR0?p3T&-9u2X7=s8gSp$sH)BEb=~{6T1@~7 z)}y=Evf8eQ&a<6kMA$y>HeU|2S`H3px-}2?<5l!I$VO={iw4A2Ft?i;&0^v2k)zV~ zZ`X}Mzz@IZB&1MwUW8V@c!Bpy>lDU&ftTD0=|K-n&U624HumrS^RIvU$wbGK!Y7Iw%vwz5j{r(d1CZxIE8 z<0i`zV~j*yyH`NW>#TdmCS`sSz_Lu+Xi5q@V8#Tqeg2vt@xE`)TBbn8A;oWcPz#;1 zDT{TW_&#@3Do!bfHA=%QKRN%MSy~nU0;Ne|IpHfs$oQX;tEbe?&lfg;nySgBK?wX9=F+H%0 zD7PSuZb%k;Kv3#7c^TFc`{2eqY_Qx)hh{j86-MvPIzS*Us=P89F^$z`e<0A&9&&?! z$!g*yUvRYR_{mNC|2seZFaO>7Y5!)p%!mnZRjxj6mAFj6hGX9r<7F98T(J`8_I$_L zz;Y0bX{~p+?KYFH$h2NL@CpCQcbhyWt!+hl*oYOZq)^J#O1jl0=XYSHoeAW#lh>8e zyhQ2r*}2)V>Ors4w)Q>r((&UCA@}AgH%*~3ww&bnrlg{*0}5DeWjj&FJlH_%NWG6(M$D=#eiDDs|7DiBuG0$BZxyt-54&cMF5J>FQ-z37m(`s zE!N?bJ)X0<+AXC`;MePb^z31kg23cenTyxJfW5~Z67`T%gxAr}_|BZv!j2(2@JKJE z$aUaBp4ef$5%Xc3%>YR_4CcJ-gY%q|4X`7n+UAqiQ(bHE?J3ubQ3DCWo{(G3w+Tec zA$RoX;|Ur?znAmN2E0r6e})!dg=P0`i(6fbK8oj+GRqZb&_t{UY9@`3O{T4Tk$uME zetG%1F`2E;!gqG!lg!8$j2OvhPwUtoo#{^Rn01%Rb<7En z@M3eXg*5|Y_R^JaLOnIlOZ2N2X1J)U?2bv4&nGQSUVzO0C(@@;=CE9s^xJ-m)t{U! ze)%{5_0Q{%|LO1VpMUvZf4tlN`s)Yd|LZT>PyXBAHk9h*i>eky_oA(x<2iIMcNLPH z>yU;^m`bGe;M2^QGnG<NcPbr7zH0G_@lVK9 ze_!9B1Mj;i9cEqy85}>?(Y@+G#-5}0f<}8y8RxE6mg3eLt@_;U%BR3$k zeor)L>i5ps^5mJW9NeVMHpf_9L?wRm>gMCF~QW8tw4)>+>rjhDBOX^k`z6d2(PaGKJ0+}u znqXUB?G36pbo8lh@FLwCi%S`M{0u($ukWw%fBoU_&oBR$@5w*?;=lc={PJ)A@lU`0 zEu5zT$F8>DR(ch= zmPp7OsDx&%38x2R#QHrM2rad-q>kEn`OVhAO099z%63?6RL`WB@O>SMWMwp0a$gJ-`BN*1Mw1}9n5-;GRL^yhN)xG5w-@P=mXn1QwcHYqCMMk`!5ZC1WFFXcMqe6X%LZSC9bpvmgLUf?mb1$--@&_gkQbydNt7!a zz;#K4D0!8X+E1&^@2snrxe)IN;I`jkfjnxFR&?Zbfz`(VNKRGx^{wLxiXMV8Gas^OZM?-csH1wPpw9ZU;n zxA8El=Z6hU19HjdcScF_e2z7OR_{2p5`y;?bo^l#1h>$L zHqKMw#Ybs5Lxx{6@8?kqXHEZZnDeoOBb&1#Z+^n1T>(Lt6CkM`BNOYwdfo& zDa`9)!8{L-#2x@}h*XO%pVpV=UX()WQTmUraEZ9bB0lAMCbGXb3({Ur@5Fq!1_HkA z2!>t?-RJ1)+d@a9zTqRrBLnM&t#W4!8M36({K z{BS&(Tle>7XgmCND-3uN0sK7%$j6GrXrDVkH7y3mR4Ju(JB?x5m>m_In3>3udJglQ zdDpCfXn_ErLLx$5$1N>i?;Fp$wJke`t`Y6?^D|qm4@Izb%+q=s<@!3nlUcD(R*?yF zs}8nTMmFXC$RF5ct;n4Zra*I+^!0j{erG5&I`9UYL)L9H7_G^?+wc0N%x@tS5^HToWQ5-RZB&7tCz zQO*Hql^r=HF$f3~nv!j!qE!Vku^zZe1VK`(@<523Wq192eg;%?j-AEduocsWJ|Vj1 zy)a_PGd8dvCGOeBXsp_-%MA+hj9_=K9R1e~ghw7$-+pXWp3U}_jN>}(m5CxDJdQE_ zDK+Q!W+jvP#{BV6ix{`><+s$zPNDL*#U+a~F_qN4Z>~{Abf_{98-+ArzG^pWrE&2s z>4Yn~2H||=Pw!59Ym_G8y*Cc$EeA%0&%qqjgI?m{6q%eEufMrE;PaAsd=^^?Z zSH7R$dLP0L!S&hhdu+=V9gAVTd%`ptdZMjhhNtzY*|y-hl@K?rnR6@N=gN>$=;-Qp zh7XG^ya|Up>=jp5(XsjvAO22T^0Q{jZ(RP!%oei;^|rYM++-uoT`@y%#Ek7C$Xq80 zw-sA2nT#dpLIzk?7RB3hP|*g0tnx$G$g<*^V{WNFi_f@hDB604vN|`Q?9ZPc1@(R+Lk*0nwcScdkXXP?w=dtcRs8}n@*;H!5p}Bmr*WZ*3Iqpa z>tdF-FBfBCXQfRLy~Kg%p0LJB%RTqSVsm9BWV*BM(euAIv(}B0%;O_;6#*CM1>>}B z^E>;>OF%Ye+9IcWNSTJPb;EPMdK78NHgkB{3sYLyQ@hONr+PM|zK7_|oH_T4$@cMJ z+4ht7*DwF(iFN69yT2BDJ6misi)#}+0{?hmUFEkh?Z|N)VbenOhpR#G73U# zWM4dM&(>?_?0(Aaumk)FfUO+FZj4?AVee?|2wP@_NqG6zR_1c=re)DINzmHohZAQ9z}a&o<`%#c{?g7*_Tk}UJt90-}X(w<^3;aLTYA;7D3okGNT4!FSlJRpYA zw!YfuJpWO(C8_q|EHg@cA383bmZh z2+-Mh51sZMyVz{`z!pZ)Jn+^jkl=Ut9hYQhUAsafg>Sz`y>)N*tNVWHznMm({&Q6~Ul>{{2hYwFG?QTKDmlB2j|1_7J6z2J~QUDyzO*vrGLl% zwSLSH%WP2I{5$Ig7l$e1syK7E`Iv098cM@i6?le=(Sp52P6wH`oYBMt4>Cdd3^Xp{G8kMJFdSvib4nDnE`4G12Qq=)V6>g)@Kn|_if~+$&ftX8I2$FLakG?>0W$|B>qZP8?VJ_VDp&J*9Odj> zd}nO&0xP<{KmX6-r85QiLa&vQlV{rzwxqAS6-8Lv&RLk-*qJ5PSk+=QiMZ3Aj38H6 z@{6PROdnMz2yI7^x%H=E0*gow=YP=3#jmv&Fe=e7L%P4g=uFDs|$$P-gph75j*DkZJ^|Qn2 zZ%l^apnp@Uj<3hggLGe>GW?NZLk%LF$6vaiwbwMdhL=S&8}@$MUEKSh9*T0|xp9_HGOK&s3ty|`&eKVj zchj3sR%%X=r|aD{m!|@$S`fr+$z^DNi!!va@1LJFq!|u0060E9vz1-Do-0x^_AFdA zYJg`pv|N19YNwMy(00*%%bK7^DLQx#!qwl>ZQd9D&-Am@gs8hol}N+KV$6gWA{i!vMRmam(sqDH>&s9EyCwro0L^~ zZC9s`xc22vJa5ll?qgsLO`Z1R%rh1xR&}t=(RhJhhX7p``K|@u6HV))-=OO|kaxpr zs>(vXr4)j-Rg#AY=L3%Zd(<+wO9zV68S4&OBBn?~PrC>5Iqs-aPn;;a?(AR~%;Z~wDRQ@lgKH{P@WxyG2wz8bM^j(QrdXRlP z0=;g}hPH3dR&vSSleOlliRdnP;aetI^Qd^kgs1{ZYW@(nukWS9J|x(xfXEuq!T4xH z&mizh178@}`Q}{_1kYrq&hzZE;KRia)=H`Mcn^%M2R#tU4*Y7*s{>ZDw@tBM&IGkq zZ~!;`F7#T#j&iNrWssGtS4nYCw>=q^%D`1Q7e0Yf&ZPCpX1izH8KqrrR&6i6&J*}-A+ zWzD;alw1VTIt-I&^`=9mJ$3lUFSl7xQ-1gJhu4-Zhw)^wpFD895^dkE4WA8}%(^+3fo z(rQ&JP|3m;fXL#yLa=Z7A_!B!BKK*-hQ>zdTe?68YPV;8=f)^&x!HBZDvd}a6A102 zPR%jML#G>a9cLa|#}tA9mW{X#<*c@Hhf z+esOg^ZEI?7UKo+1&3)Xlx%H2N4)Nol%bW%)+Slq<|()3G_MEEn&lcx$>Dn|&r7>6 zPl6K<(;don^o6BQn={bnl`MA+NpH-|^nU*R8^oG|syw7IV%gD7c^9)l06t1Bb-(_5 zQM4lLlZzD|td&og;5LCJdvR&qbV`MG>RIclJ?^CjjmM@IDe6#rNFMv_$Ncln<|dm_ zpG{xGqu5ymA#|qBRG+m!CH1aiPSXqYbANkQA ztmf#nft^d@-U3M7OT-2(kD$O;tt6gi&o+I6*HW^)7lRSC{|?!TC)!Qzv{?klYz693 zt$&}4;;SOvLynN7n1jCWeS=OIkQlj{FcG&l`UseDTx+EbYno9nmE<;Clyw3kCRZzX zwFtC`vT0nHAH;2ZoKb4+?8PXgO4iSxA7?tad6gpx)bh~HHBjIOPu zYx!2xm1XrYsWU(`tz@2*#n?)5!?s#Sw=6jz&SUeMWD^2bV6A3!<%98$^^6??YwNnm^-gbXnAO6v~%ihcUka;J#x{C$(cM^L~_$# zXs(&K`^wdfp2BW;u=C&bp*$+Ii^Vl#zhDyW=<%~Q`ER_xo0XtgUKN}$HlmiIfnL}7d_kL=| zcOfD(ghw-_w8xeL5GkGFO)^MBcS<`WdISdE%%zNHV!_lK^fC=(VH2DxiwFz z)4~=5)XG=o>abX)+htrya!@tDcg7!#wT@E79^r=&xWr!OVbND}7+}lhos+S|sCI>) z#h&+chZAv=G+a&3>1CpYfs!{W(Ph3@R?i?A-21)8T=@C~`ax4@eBNvTkVQ}77YRk| z1(#5)gK9&u4dwN+dmoeh z6xh#WYn|`D*~nc>c@AN%_n1RmY9wBPHLr-#Uw)Y53?1PN~2W*h$sy9r<%3AwH z8E;72s{EkHI7g}Q0{3id_nzlHq6{DKlv=+pJ}NBlUAlVCCe!CSqsb$>3X7SBgEM*D z*gU%TTFSC=#^YX8F6qxZKFXaWAI<#Ws<}5gykb((qtV;dEZgz0Yyh~u`o6!zc!);O zC^|V30EcfBuzC9~_b1<6u*qA73^ZW9YWK&oU{y7>Yg5^4Nz=Lm&3X*0J#n83I^aa% zdd{8;WkkZ~!ewC4RS^w*$0DD#Gi04dDq7vaXTzu{NMCA9_+8azK}|purzd3kP}Uw+ zoXyS!P2jeUXhq0vxpr&|*Ay*PO+3$>62^`FecosXur)3fk35Ks#2t z1#OiJx(3OQNuOgli&t2Gw(w%R5jHBce`|$NwPS=`KfPI#4%Y){VcftcM4YPZr<}!V z-%D@b$6GI&D|VzbNhi0}U68?vj3F~tVss6a)}PgKZEbVsgaEjj`wc5O7e5bgUS4!z zX^TUiaV?CA>?uW2XCP1?3v1+w>a~vj-M3j3ge1xr(s*B?= z(rslboh6QRI`1c2v%dDqKn=7u-~@IBv(CgQ#TjVtgO zWV38(_mu4%i|gj2y%5BXGpu{vF;Z{3EGOhUk6z#y01iTZij;Pt~LF~$wU zP!L*}&@z3y58_*y?N55pTp-d*yF>$3)*}J-4HA9#HYmdKncC$7GrL+xK_IaCi-G9+ z9oE?(#z!Z#h-1yc1OO!@IX75gdv)0*>gCS6r^5MX6z5{EJm=`Lw`(Zx-9B_Q_Mt%ZywFIPT$t>s3=V7Q#RpLf5UP=B^~{o|kh@h?9x z2>jD;KGH4ehc41675LNH7rc2gZNNx1qC}P90BXi6rWqqF5)v=cN4K2MBkt3oK?IvZj5iNF!4(HU( zwHcTkOtfq06!CufucOChP?Y=a1LAn;G7=Rj|6i|~$KdU8;{+_QsmmD@wDmL6@c;ON z;s5pT{;>bi{JdSVd|sx-t}-n9_@SiM5WkF!=^AdPlVn;&_IrPx{ zF5Hgq(irosVEm_t62*-$pGPS5kC9CF6OOPbn7KX>ASzY?-jtf_2Hvq8EL7Uz=XlTO z=h)d@Q)_SB_(#Qn)C)(E)T;UFSS30hr5p7K*cJsuH}_GBs7+H<3?yz(8w!7F13}P#zhg6=|=;pP!Fa3P%J>?XYiRxk*o&s&@ zniJzW2CMo1vUc{m+U`hN77`K>1e^goAt7*;%PxCD;tA#y%2l=)%}=B55eOkpfTKp& zvnC{4os6b;?_S^f-uHRz`nm7xKBV~Mp1>57=k0)~08MqOVFpup?Fdwnl#`V-E^ zMj-5u`; zoG_vEMdUaUJiliQ6LYkV>_`G?H@3&q7I}4~HI=zaY&Wi{S8$i#97(70c%{ zzc+JI+8tu|wvYLS&dyP6JJHj>9hwf2G(KR>RwHciTHLmk^_XYIIH1dM3mmbn{r>v- zCoyyw9nZw{{_?$3iFqXSHm0p~F9{axpa+PTzZd{HcK#`?(yZLZ(ej`hSHEe4KRQ1sq9`u{<6 zz!2~m(N{_4ub-bA(*p(G^ZVX@HTak(Xl&^iWLc`)&Cb3hZmmj{8wfz_EIg$xXx;T4 zoY12WU=hL8;b62Q6unn_pe678Y(d-4NV?_mR~Y+k^w-W-vGsyj_mF9Z1OMenU#me+ zTswE$*Ti0$phprGm1Jq+S?fN!T+#-9{rv39v_)>X;ZE88MX<|%#H};ifPO|sEzvP&^e4}i z;V}xni`v?V63o#Mu0Ch}{IHqKZs{at;w>omg}r`8(<*J@n1&abXVjLBK+VpaW`T+@&lRT!y3k_kPpS`B0CR3E_#X z!jD7ac<>t=yFK~v4wFp0iIHnbjY2x!83;ffc=6B>T%Zy``aJSZ?`k1&;?#D|`)EOy z9T8Am+9-g=?_nbQ+Q2%Bkuk^1FVZNjv7wCZWUYR#w9mAFC}s5NW$y3cHwSvFy>;Rt{tyOu?`IT2*DCU6osrA~=w+D1LRInY|6da|5pQ zXQV!OkFLd+m4*CyHR1<~>8La9_W%Vcx4N&76#UDkv$V_p$o0PMyJ0{jT2g_el!b zw4uki9!_5FJ-&1zZC-cUAjXx^sNKe{BXDe4t*Rnr=gELWLTbg_XT{*MW1~gVxlrxw zB*Kj;v&3BNfQl^^1Ivxt@ArP?d%M3V0$eZ^wXv|x&}POGHI#x*S|mGCd`)1 z70@w$7;-@E7lW~kPE7$HdF~Y;)2{<+?Q`|YI1^qC1nJjy#uuG@yUrkfjiJfwYYAbz zarHYxPuG11@HIp~_E%5^&wCj7bV}!ZcP8|e!T}K-oltA`(wsb0xhM7*OsA}8I8v`h za4#=KpZeK|x==-xt7o+h`qr$x52m84<52QPZCbmH|6h{AAOG%u{^`&EaR2-&n*0lK&b(LUy8C6(4&Mdjq>1HYLA^1KKf5G zRyVP1bIW}D@|#Z7#fHmf_Pmqb@a_2;^--|giKajbQZr)Z-Q19HffLTvQfpu2x}6p)HZTN z+X9;M5$$E?>fU`_h`(*koz=;#Af$V@ZDig)#oj#$4%!h`C+}m9IiYupTv+$JcL{&L zmpbg#W@}OvNHSQh_7h;TzBqT%!@Uv*vjiWU z*M(N7O>Nw(F3moiJp8GU{l#6_?^m2JTRVHRLb~f4Ec!_4LlTMG{w9*2{a}~%fe-zc0LOK9AD|o(tqTIfu^QqQeN((AL^;OjBx1r`>-n7f z_jT*5>f5$?*i1Yw}abzSk$75jE6?SU$=ES3BIHXx0Z+4 zu&eqoZmQ$TCZ8wdWMv-*y2S7AUpOoW8bv?Hs>RVGA3k=D7HAhh(g!@wunRYne%-c0 z*qBt@es!ncMQSIZZMfo^D5+2;aHbzg6#zUy!@r151`PG{s=D4dPsQ*2JpeUK9aoD( zTWZx~p%c&9`#sHDzC82np*Z#p?;`R?w3L!74MR?6V3awIIH=p>c75!NxjjG{p@h75{}w(zR-GQ zsv^3K?>{%>C{vM!^{N)J0CQ|{c2nLM@pT2Lz&3loD{o!tyFWZi7d8FHIU5LBXP;n8 zYX5#`dE{KshsJu+1j#2L!=c;&_A-Rq=ZnP=BpfCm!o40AH2XfKvdaIoGiL8f+l1_wLB|7Op+o+=y%}3Fb5{?40q^ zdtWqWYmmy)1H9TB2GVTa-!nED7S%kfb!dt6!rAZbYFje|4++|2x|TWGv$fiAQUq{D zj@7a$7d4in0AaHS75Ke*zaw+d5Zz0{Uz@N0kmc-PP{%@<>-QuV;T#9BOx&c(m5tM-TiWGocOZq62;<6BcrbKk3vl~8qSkc}G7b$wytgZOCE zw0D_z4*h)q*Y`-y3p9ioGK#tC_Y0)DEhrU0knNt?lNd8l*zwtIFIZFHCWGFvHI3J! zz2-0oo{^-jd(Yq^-bawB?MfQxhjHE4`YWWLBI^%w+xVUD zG$_>lhJ5OhKFNon(!{%I`fMLV>EG@>IgLNx>L+%K+$U0X9p}Wk-^ferbDv-kfPb~n zTtuBvHJJ|j;{d%}^1ILfZ~pJU```cOkN@<)|M=(lr~Aj>{PB1H{NMlSZ~y+E|Ka}m zkN@(=|G0nt%isU$pa1xq{(t`T$A9?m@h|`FFaPy_{q3JJ{^d`9<`4Pz|M>I&|JVQZ zckwU(?fawt=HLGDAKAJ7tyY(XB1AjCo_Dl zD_CvWpWqN(!qaD%ur_0u6LT%q*D+FDI+D}%>O=KD&-~`637UpA{E6BU-#%nKCM{cT z48TT9>zGutjnx+G!b(E5_5;{Q%uowO#e3VRI31@hvtR9(FmG(S%c9Y&s?=FoL#HDP zsYU!{GUlEzNrq$)^NP&y6IgCG0V@X9E=LEtch+09h~qKgM6TPdx33E2DS|QCPQ7fW z!M7)_6_29Zlr`I(f;JJpLUX7Khq7!_npOLNwUzI=t+i@@Olq}jYsP4E#yfjPmv$@~ zmC0~DBUi6>=h5BfxdSt|bn-W$cCF0)DsOmCo7eqhEE1C?Gtq0A9hr(_z4IYE^L>ac zx;jE%Mi!rO@qQc&ix&B2p*WlU>e_qwKJUA*st?DR))+WW0pWr7*{bbB{%lqg0vwO- zxrpK80&PXG7}*_eZq=Fu3N=W?>?_U;x~|=B!Om5NJ|pdLe%8dryGVB(AVb6> zdWH(YNPsqVV1^LB2p_wVVAqL@m#H)cy}#Ej@4dY)JB3hLBucZ7z2RPhAqKt;H`+dA z$Ms=f4N}LED74+)sn@W%E1B-Bw3%6^%F&%8)x+K zu{4JDG$prV%xJqcALn3$D_7#B93_D4f*1%!sLcmhw%C{5ZT3l=bLl?$CLf-9*EyfQ z507%0hIeQGXf%pwCxA5;sF1<4(3#Dh2Xb%Cha+NdZdrRp*ERfoMwZXVdZup3t}})r z$v$5Uw!u?!eSHE=QFZF;d~x8?C8Md0Ka8A$K=j5^WxZ~FqAB5A*t?I=qEGskm4s;l z{t#d-cj#PSO1#?r&dmeQbU4!8B8K^7u$#aShUKX4Ci1%+b4t5nCE{OJylkSso9F_o zI;LMdij7jNHH(^cvyRHkpKf#!>CvzS5o0hVYF-bp$_hZ==npaT_`A;jL^{0a6&9l& zEd9#w@af=x8ZmU)Eta~+SbZwI4F=WOf4Dr)p;nN)!sz*&$V;BB^z-s?RV>sJj%6wr zhBr!y2*PCMlRN5kGI>BZc$12G<@g}&ye|@SZcM`IlMVXAj~F`>loB}E4-IFhiYv`v z{qXZbgCMFS$mR(m3@d;HC%<1w%4Sk`&&Y+Jt?nvi}I|s;tX<0`yIRP!NFNJ zG`f>0!2aC7*nug|(R9&Tt*!#P4a=Vw!^(4JAJ)P)8$wqRQHa{RrFHEa3#0Yhs1|IrI4{tP3}nmK8Ywu2 zvgjN*7r<+&oN9ct-F6=%%Hg1Tw%Ke>U>t+8mc<&4M0SnVIJFb62XkH`kZwWgAdRcuwCAs@VX@W5I_Dm9zN7XA0Q>~~Vi)P+F8LT{ zvrh&Wd$KZnKrI*_70!{{NJ-?f?f}l-$0ZDJyMd$2KwMm==w?tDFag4m-_tKnIoL$I z^~g4ckG{T-2QAs_{@zOua=_~&MIAE6@ZXcy*oSUE4JqriO)wvC1epLt-d?eNJ>wWs zOeNw6wn&k=lJ`p`kcbn`hH#Q4Vkg?YF7^p6?6S1f-S;}H=57~ht>ubwy%C;;Vy;1* zgjl~Q<*n5hg99FY3TyX9o?iF+VXThxSZ}5bT+#N3aw}c)cHY_)riZ=P{18miZo*pTsn{_ZV*O8CXoi!} zai@@}@yIE&Ci4sSdJXvQbBJ07%;J-k-q(wJ(szTMx^s>_p1lMn957C>9>dv2ZmJl28Zx6)(L)7kF@~(t5UYZ=3RzG#nw&QL8nxr;sQKQO?`ZD_*aMvLD5#`K|o0t!`_(uQ%QO7qp z#|&wgkf6}f+Zz)gEFrD+V6S`WK%IzI17is%^rfTQQ}gX|bT*_dmS@s0dg^p;C1+v5xf zh{Vst#rt|7BRyE~pYMgy)9`3FzW3h8yj_MppjKrI6eBx*-mJDve>8gwKMPmZ!OO~D zJ~fk8FE6W(>fCyzDECYly9N#>RcS{GIhcFbk8(af(Oa; z2aAUodMBb966&P&$-Ooy1SYv}sD97x7%caPNUBkH#wWv7p0-Jt^(eq|hR%$dz&M(g zl%5R`k@=IEwjwy1Qm~cT9wI0r zZ#}KP2gysTxO!wivh+qUYY$$kC+sF=Gm15!FHI948?g%HO1H6#S)iY(xZtsFN8&Ld zWeR1?cR<(3cAOCd!gI`a-Q@Kgf(UCIV8o|0GUY7p^1P?#TfB7w^E}4~P2?H=m=5;c z&EIa>gd=8Ku7?-jZ|-M%!Jk!^KC*K_@8&@Tu;7d+DQo%2O>+Y2sqi5=-(v6nA#IuD z08_QTSMSaJZYD}?MSwnk%#d^3I$_P2(xxmqv}JyL%cB-XM!B(@cwe6|;jPgJ;f?q$ zC3s9p%|r-Ufj)Cw^rnPyYo}v0o$p<#F}2+7i>TK(TjEw}nQzN=!2VClCiSw*5kwo9 z4ihjk9wZD%U*X0G382|U)y?-58-F}$VgY0u#Qs?9CasyXuGY-W{9};bh!z_S9ivb% z*@tYrzA`}WydaAh4T`tZd#cs#VmvbgxZc&F+>{&q9mc|g>qslLO*-%mHS%gSAg!=mDk&VMH*V!erGe$++`9Z7UKvB`+wD@s6H}20 z!qII!#B(Q@F>PvAB7AQrp0~!hU%upRfQ}W23M=j)$Xig&?RIFtaPThpHXW_}O3G0# z3((o+wy&K_2D=~djNh!uuvR^!S~kB;>1t>f?qpO*opFZyY!7ah;2c7YYn_cg(=`9+ zX;?+QhUp~L_rA{5u=Jr%jb6>XJ`x8}tMYIJ&S4C376-K0`|MrVcYSDI@raiWIFU+a z%G~QM{D6-WVfECHFpDzpkz~;0GZN?ovW?3RbfQW-v-5%3Qzw)2y*O(jkful{h`WMaSAaJ2;@f9<4kWHn$K3DX8qu@X&#dXzA$;uEUSoZt zNcMt>)NYYdk#i6!O>mV-Td!q~@$g8J!$t~VZ~ObnvjLvzYaj2g&%DC;`vG1;c$?As zwN@=*5rjfm=;y(li{65Hgzv)s2BEi$E;aHtGX>PM7oLFecFaf6FiJ z1(%H;_7%#R$+!{$+}_KHWmobtP&5WLsfm9VGP6Mm@22)4nwh4YleCmXMCI_aCM$-u zwtbiNJ#!Ip{bs+{qi%>^)U=G7`$)e&W=<4KpX-0UHNzu|s+#;-aIGu~ z2vZ*>?mH^pC?ux5!X@DPp32&7exM-2r2y6n347#;FkNoy1xLLz!+xarRcIgGGQkON zRL`@`&Dp^L-I4CK4Ie@!a@{9qCoj@c)Ft;vfn`n%q&&@w>HJ;}=pErybtwc2>9!zP zGB&_xd%Zrc$^p60u?l1Nn<%7brsaxmjKkq}C$8`;S&L%idp&?ZwRyA-DILo6k?BQ^)=D-% z9x7!`L(BzCj*jt@+H3^ual+mz;@wy>Gi8DFSgTzx&q-N+f=L%O^Vg+_4jfwmILF$n zlUaG!`2r{VIIUeo{~755F+%3Ny1&})Bpa1)HY|A)k?w4tnk3F4H--?)`z?kXaHH+b zSZwF+PN~wz^#{?I`ihPIg2m;A197sfh;>{#xwp=Ic_1K9{+{i0q7MxNH9MzsW3)4d zMosos6WPg)>ks9=e3YSOgi<#A*mrzk9HX(6*mWR{w7tS6*$o4JN)w$@#uNUP^)4#i zviH+!)<=y4GqxtZ4Xn`ku;X;D8%!;Ln}FAM_(BJtf?gszk_ty&!-<)V%>}_kbx$kC z4|YJrQIzcdVTD0I9DmYu0JNnlETSZu9II>6&h7guljP@zRCT%AwRZw9su6ZPWTP(N zaYSzq#vYUQ%y`#KTNlJ#Ny5r)T-ccaet3oD`sA7#% zu3oS-v}?kEsdJH&a;dh?c+Tl~i4#1S2p@$Cb~g;ctB?3X1`GP3FG@^xjWLBV*cwj{ zVgWDYlgxk`cACC?wCLF4Ix8C;L=~R)5Z^hX1$O6A&sN`D`rjDbO{xRq!y58r>Lm&U z8ShiPAiMeFw{Pd*pe6ms{K%+mCb;^Uz_HP1J#DO%Sg@`JHuTfu%A zh{xdh`@RUl%>5z-2)}(bXtsp{=tYMEEsPn+eMK!!pb0PS^NEH1IF=zSMrit_&Yl&a z$oel3)hzIl5T+PRl!lA#ky~YjlXPESH)R_^ytO)zI!Jt(?M&v&!Ro&5W!H%v7g;X& zy3NLGZM}*l7Bk&$eS%mI8(PLfcwL(Z+GXQhBvw=P(B1cTw=j3xyHEcvYXiFyvCr$| zEFfvK6>5X!%tA_aS!A&w@+!W=p?8zdrnuwjBS&i;z}{(N3{TbtAx2fTh1y4 z@!+n1F_7xeKlEo&D@a9`A{7aZ1c|5Cp?bx#zrOF#jRrx;3Rr-fOBjb8#SmG zYLg_Bn2o&zBvz%gJe3ZTS@tQU_eGkO7`sG8TTKvLtuWCs2vRfEGbA2Rh%J5TSH$y0 zWp04NyfySShgfwy^SPm@os~KAVq;13jDh;0axyg$mV0)>mt--`>P!|=&|&Twsc9C} zLWF&+aV7mUTx0p*81-+rT$TD+uJz?9wuZVA@HwQsMvMo-O_a8|zLMoLL+`a~%W7sMDivqcIORr3 zc!m;cOC5b+MlewU#2sj58!iJ1r&~Sb3`_=+k3mqeiD17E7;sGfJ(N86krSjj(S7+h zYhs$TCKr&~-37}tD&7-Z2e&8RJb8ka<34r-M|hujfI<&~&T3B&u%S0}LCg@~RRFjL z1M&v`Hyc6(N~7}~6O%0ykv!kddYE>Ie8}&-dwaKSB4YYLx8mo7Kl#*(R2^*`d_c)*hFoL%)#^KNB!TaI^MO6GXoh%d!|leb4W`Nb;P5LB3bggRkXVJHx*SV3)k$NankM89x0&=4<_O_C3&q zJu&Pupdc>>`6_Wj=VhQ{?WDktP>$?{)ePG%-b08=sC4>W@zEtHuk&0f;Pi-o+y?jw zqA8!(1D9y)ZtjRJv#ymLb`L%6VmP1BEPQ2G_B*241z%SNtp0e_vwH3K?D?#NE6R6b zh?j-1VBa|=z-5g*^l&R)_}4|Mh`eyapMlwmUjZ8tTWDA5mN^)in9jXbnp}{FE?B~2B1rAtXQ|Vnlosa_Id?10cnh6ZTVbqE@X#SUxVD5tSRQN zmo^>e!UP_=zba&I3p>0KvQY#3IyTOm6x|zAip7A@GaHOA;3vRVyrb%_!|VwB1eA{; zH4exS(F?dLNz>XkW5W-l@gP29l3Yu)hjqw$RXfRZR2paA(Yq?>dmA8B*$-i|FB@t++c$$Qb$!!BA?kHK&@^r|p|C11~u- zv2hPv;0;__+BzkBBRLag+XEbgPXWQ%Fhb3oz>57aJe*Yx__n^*NV2D|*=UPnzIive zi#eY)C0+C$1Tqp*0}rk(eA#b6)!!c!{oBR&*0#@F;BF)KBXeoxCpMHs^V)Kb4oEN0 z!viO1ABfIn^fPDOd0QK{(4w1EGI?IKy@INZG3&U2jnLxlMN}Aj;~iGWGf3arXF}_E zEtlIt8#~mLiQD{^O9Hv1<4irvP;5=ejM+1l-#*f?WCS`P(9v*hAA6XN-bd+{P7XSG zQlEDTd4Wh(O%`I(UF!;wf`OMS}nwzoG0QCjQD6rY&wDq(~k7TkbG>U^m|6_ulJ z@@Rnd3So7GXC;Nx8hySmhwb5GybScY|H&+`R2Ak>&N zKkj4iParRX_F3bFea`~URTxz($vS&B2hwrOscY8$=ss1=;poX8=v6dNI#EXeDFi(Y z%m2yg9}|i?@(2Egw`32#63v=;CZg)zw#sf;>!E$s7Y+bDF^T%BgVk}R*(rvx2i*2I zP2Y0hQmQVB-D;X3cCv)@mBoWJzocGqygZU)w@02l3Y40~?7?3ju5mVCcQRpax|2uJ0_q(r47~ z_4rWj#HvL}Dw0lK?&Fo)jdiE2Xv!cHz87kXzD8{tf=C}VJn(YkE1YsOKVQ7*jK3gLVb|yI4*l1RD zs5Xq~JdU4OoZ9uJe;SRRasv;NrDB$98&2BB0<+24o%2Yr%2!hA8Qhto7w`MCXQs$u zT$IvNAKJRwYcmP#U$Lm0px_l}g;;$v=x{~GJD5py?UV_v-$l;+RU<*~wW>n1Xq!w3 z>SE>={$Ld?W99=%Ac<6pI>ortgo8xKjfP;9ktKB=JJl>2xIWgt?R-POQdW4{Gp~Rn zzJ-Rt%&xI%+nZ4YdcQWwA}=q5LLEvh0qC|qbf*qP_`*v2bb#l8^KETpR5G$NKzZ(E zj^%RL+Hd!IHpAvqCx}HjXSXBou48F)&AW~H;J(9T90EE73h~q>Fph+ zb9@LgFyeeNb6Jc_8{5aHupyVI=Y4wXh%=fX><9EDv?yd{b^6=&3I|&o?GSx+wti#q zksaj!95^=L2YK4`=hZR%Oyk?2oWA`%<@}aT@X*G$F_A?Eb3m|=m+7&gc*@6zG@tSJ zdZi7puU&%?^f1`{C^-DQA7=nc!~G?vw`Y1-+#7Or- z_-tQoeJ^ig5I#1nv)T!D5W|&NP*=%}=q4QJpbf5e2cXqC- z`2sXMtrIi%4HTcj_wKzf1`Kmk?rtVJLw7>Ms4mImhVcqq*lj^NeGi zY61Nh$tBidDls$k?i-|V@xOYRO2sAKzql*ZQ~N7fC;+MvUIcu_s3SF_fsEz1GtHw{ z6dcC}50(c<`b)yU8k^+XJ&2J*yDJnhw(z!+RIx$l#iF8{`CaKrWT!urh4buP|4y{&Zk#K89Zi+Atwc|!m3v8dQ5JD5xjoV)$3LWl&vZLP+jY_XM@nH z{e22R>v*{Zb1ub!juG?T*;Ik(3+n1Z#a!#j>jI{$QBYmn9dVjfp#X&eiHxp=^*~5E zj!1%Ja7rFSmS)o?)%icdnc zTXQvF_M2E;dlaA)pY4l}w^R4}7XfiEhK=C1{ZXZNvuVy5p=5%FE^t<4H8zj&_#vTm z@gohk&-k2#1J!nme%VqYGwJIKZ_LXM)V~T?Qv(+g3>ospPm@)L0cs+;UC;H9CL`QF zogewtUohwJIWBoBfC%3igLO}KbLM{HED5omeT&^S`v*BX!m_tjYFXyND*FL=Zv5palm1RnCA@#5% zo7sC+Y>oCqp&J}<(@J=tIkyf&kAb3&o;2J<$~Uo$4lj8%QfN@-I6i_@-gR(a<*h3j z<|lL^?&Mn)ZCq3Ih;uMR74h79zXW?gGRDw)PDtAy%f646c|TuIgB)<`W=B@b&$@iJ zWM(hq=kJ|#G|CT%mzFegPs8#KCrOT8^SnYb{vlZ6vu3sX0k&BDl*z0^;@LgyWIXq@ z6KD0nYRvF$baG=qdR@b$e&I|cy4}4_Z$RJ*HE);(V-5J!feahn2&%RAV8rDuB`>Kh#^Eqp0v?k=KY}2xyLM$h^l>;W(-r~> zSp6GQ@0vJh3Tq40k=0*6UBlbgqncH4i=DgL-l>f&4G}i)#JJn29|bT`nf6JbzWtm$ zY-0!>*w!L1eS@s9(Xi4CCekftb&;X6S8AIMe?b?m+uQ80tuY5r~Q#SzNT6#_za5?L8QV-Q&)h{($=)B1PL z%eQ&T*aBtK9U*EFHIp2X(Wyi;$QMG$xA{-))9qudNr#Yy8ZPxgttctM(;6 zEPpDNkCV6O+xz<>klfFCM(QWl;+C6tG29R}MG3>oW zZX%-Cd3V0mgg&SJIL%TuA73ub0ZR1f6~;**q_Cq4N;l{pagMZ^hs?NLlP4wKhuM(# z9TZc8953t@{$?I^bPYF`T;~m7;IQO7w0rCqm(|x?E3xT8C*f*#!*IQpRG(MWnJ4G@9tg%#_W}a6@m3R zlqO@@2rV9qED~7yUIqJ^z2zaTO|YHj8oO`JebJtMrsdgpOfCLIaW1DllfTXB2Ne9-C+m*eP?k8}{exxBOKEM!GJnF0W1qAw%*j1Q8n?=?B^6PPVUICq6D z*X>7>{LJmfN=%(H1jzMVIROXuHg&jfc5)-uo#P-}yz#zGT*S{rX`CA+?Sd>bCicE3 zxp??Vk-|+90U+kQua&{_{n%ipB_}wm&9M{U*!C|~nVmPQ(PLN?Utjnhe#poT@wVn> zZMw-8@2H_DJf7xz*m8|DWVFGvcX4)TD4Cmb>*i-*vxM;L75qKD`PAoPIO*?=^{wDL zve40>Y?u2w$Jy)nRlHq?!Re$_i2H3hH|PsSK_R^G{!O*U-GV^n0T9@yoGzfr`_^NR z{v3*dep|3{Ed#EKe9~xsXUZHd;Azn0?}O>v=a`f31cjZihw8e`PkB%<=vRxTF>thC zInKQwLAvB%Y=cZbuD)?c|3;rqr^SvB819mFJJK+muNqtrpbqk!0=6cBzm>agL_2*8 zfB8hCM1CG$F0%rf>84lZfVoL^u8mlGxu{%fv^!&$D5lMVL4J};SEV0_Y1jo>AOJ*=)D zSRHyw$#W_EB_0HoM^C=p!Klevn2-)p>$U1tj`ZC$W98~+e4o=|f5**nHO{Ak!dwU& zw(T)(F@5i=9f!0+mM!x?J||Awrl04Yh~&9;zvU;`^2w)(uwb;!TaJ?PYhrbV%s0vG zsj9+CwWbI-R+L2m4y*|qU-Eh zwm|OTV2-m6z1*y$aXt=!)C44dc$1#;8K`e6%EV{Z8<7`+LFAYRBT(=1rQ_8hv|)~b zZZYNQ#`l*4rzA%mcIa2rmY2N~_YXB1k$ zad0$}@(8$~N58&nUEH`0;2T2-cHgF3R)SUGiNKF5z+yMLAesduY_&-Mf)D zc{?7UHlAV*8U;T(26e%glxgp|th3a+4?nFu#H%4J`Y3>7;OJ#d_8ywmKvwigvFDj? zY-}{OwTD~?&42FLX-L*Cj@{j$PxmkPV<8cWAxFMACuuk6vhq??vd(Gx>6BT#E@(r` zo4#E6`JG@#qsu6A|Kbyp^pAx~$PB9x$m-gmpvv4lfg!`*d(6LkZDRV zh+wJC2<>xI-7gJky%b-8pyTN)ml-Hu=2;1w-pl-I~V}Blh;sYl`$9b5efZ)=%B1YehbRyrx z74s}K65?QhLt}atyrY$X7b>mVwR@K!F0JrZ3OTQ}9IT)TQRvJNkt=h$2;`4fUkQb? zj<2L)jV z3w9+Sv;t#bWjE%`?qB}w=_HvlQ+uHp_5@;v@8%ZhV!xkx=E( zd{8&!Lmm0MF(e(yH(3uM*X=Rtg2noo&<;t>ez#OdOCtGRFUxbQ@NuoOPi)BLklC>{ z6E6Ib-cK78c#nW>84Us3pkA7+N%nlw@{XPfiJ!(9pi8&KmNt{{!T#3unN(7*@kI_s zU$d3bvu);?V=n)UD(bOE>fFtHK}wbh;Oo0g$7RPSk#d@M5E3!u3Urg5%Y$kbvco~x zGry(A7tfXF967wxhet=)@X`%FB{MQyGJxIH?DO+SG<-%2sxrFCcr2(tD3E^=C*sgC zaa>aFRzQVCKG=*zzqYGY=HNKkWV8~roGkoDqVXJ}6>WQMC0E+g8|Rb1t7SO0e!y8+ zYhr(~qWAKTB?->RK&sU@jS_?AEEEb2=av&H?hRQw@d#!5$TX-9pyeG%si6I#90YwI zvfRMdL-4OHt%;uIGk<+PYY@2Ub717XGU&P+p4~=#nGLI0<%zFe*e{wI1f}WfO^*TD8vBgN zL!_AK_`g7l5xnX3Vco*ht&$69}mu^ zHsd=NDmYKTuqm@wR5kl)oZN%lFo+58^lo71`$fjmSZKndwW=4fHatjtc9s| z?D~L_wj9-%|M(*a4B8!jM$2bDMjM8{ptal2OquZX$JE3G-N3N6Y3(uf__T;b-6{r2 zJ3yGuCw|{!6uAqqKFA%cBtJ)^l4p&TywH%?_bhCl5k+0&y`K8B!D?t@6(q)UbObrC zFNAJ8dl&UnnR0I_phH)A&|6khsKC27XEr-W^GCEnJIg+S$RqSYwG(-`w_etGpSKpE z$+!rBWp{4;u}TDS&0CLW9aAFp@~VzN4VklyGuW6m?2)ubz4B2?F;fwwbVQM3ziG5{ zq;~>!Fb-ap8-!-SecPYFOl;MJAsMn9PVGTd+J)>kJW@e%J!Zn^G_tEJ$n{0wb1&xC z_VSgnpT}0n?~Txw&4taI@;NBx!_gzuexJ!-ZkzNc{yhsZx1kbtl zosKziZ@dQ0oTqFZ1q;40UHT$x!<)Vf4?N=3ZNM7u{a~6ssHy5Bp2|B&9G1sAH}C3d zJa(cF;9Sl_a^tllaTZ9JLKlhLpp#EBg0btJpneUf_5e6mxTY(IF=)DzFdu*#8!h=7 zfln9vQ(4t#-I|A@81W+E-NHC;DgZfjy!R14$Adn<>HJ+Co~klP*jlisSuam*>Ekj& ztD19sl?>Y$U1%aH8_tGaJ+>1<#9!7nQF%;RP>!&DGO@~GMkblNnTuSv3gi;uN>l-8D}2))T+vdN`i*hekV z@&^BDgYIjVe%4?r)F!Kg0U~1zHE(Uqz!^F_7sPxdM%tCEXwLgO34k~koM$0QzrJ`D zsEg9`STj3tY!C*i-d>FMRqmV5bV;+PuqPd_18!reTuDS;PEs~v;+d8x%>hlc&FIoi?x)+hRbh$bVXRJ=V)e^^qgj5M;-#uvjFEbbb&A*~mtY!9W#R^mL|M5?bn+I01YJIgOlVaB)dC^jQOBPa0qi zFdL)M_i3%?d0(=A?)$p=!~oJz4Z`zdrL{`qWMOj!N3`SymnT! zLNeDVbJ?DZU9_Ju8IIJxOF0wSCspxyb8*XA1>{=_{n0!GpfioVwxAgfX87b#I_rKR z0V3Bm*!gy;gq~f8JWD!%gdsq#UK{P`E4#T?u!>YllMr=6C^SGn-@H%DpSum{POFYH zLy%5rd)CBcjgO!KS$;)GO4NxIaz7E}uqB-910~ltw*GC5wb?y4B&b-OVqM|`-WX|t zMg+Dai%<#%Jq1ECv9x%A4+DzcYIYrup3xnlRaLTFC*r_`ueB+dV2ys;N%H>2Q-d2u zeC_cv&Pe9TWm-|DT)J{fjdIa<^n=^7&!Gp!++rhc=$o9xq785>OPCY|vsAA>q{Y}( zkUG>+Ft}j>IG|}&;rqS;aP78glyqMH2GRl-N2S0}qCX(h8RyAR=r>0+10-Zeei9R= zIZCM3TgfZ7oQ2|EGa3cJDDVC)hsv%qxMQ%Z$_Ll)_5G04{(wMrf?->05ZA3lnanhT zM>2w#^mfb#=g>_rT43B+!vcs?9VIzx7rghu?NKODqa$hJYpvgAvSyJKZ)bVns%kohZNb?hYMgj9~ za?;p(%;4r9wKB`H=ZJi4Txxx1^I7bOwQ1ct?oSvj4gd45+3r0bj2=b`b{}1&QKuQO zx(4#9t#WQJVVg{#;jcv~`}Do1t$@6!iQRU+4TB-jhA3)5kpa`Q_3MKc%s?o{oxLm{+}KJNBxkysVGb ztmCN)iyg88AQ6E7*b5_=t>N_y_Hi5)2ce~C!y%u75(4@@TGVo*Fq!Mwy&b%vV7vfu zT>(dT2O?miJfrKJE8=AaJP!40J-qM!W;N$*glTJa=95VDdX2IeSCQ4kNURTf;Krb{ zughG0Noxbj83IubIpT(&gPI_V2M-X@Y66K@jVlPy#D|%YV*#yd6w4^3KO5`Yp!Qxf zh-A}6pT4)&^5ojF9m2?qVG&_zKijQy&4MBurBSX2iLVSE@ZqTD9Ssqr9_dSP6v1JC zIFJRpyO_Pmi>GRWc(bva^bwOQ_%J&LB?4|4vmDo4w>oYRGGVn&*v%(swP>1)Q-mUn zqXHrZ1d4K9{k%wC79vQ+^~xidF+1c~*|9fjP-OlRz23X%P$8em3kqT@%s)eZPxm)S z3h03I&m+dMwjXRnAUW7BgQO0F<{y*>Q>nI45F&h#MuSry!Hj=7yP{;`j>lSzZYHcB z-?;Wx>Gap8c6B*veaj%&l>w zUAjgjIybjGACchGae9UQ7V{VY`ZFiMN2!mh!P$oyd$DR?)yF#Hkc!+2HdtFcqdr(T z5|JRWnj#pq9s}@DyA51hwMn^(Qk~=TGW-nTdq?UcSwqXnZUaaZ{yvV?dd|)o4*dy^ zXTDhpeQE26v9FSDs|S|$+94cBq)N(V6o1BnNB}{#(zcn=y*VK^)56F^BE}PnPPg#V zptN7`%wvrE%n2B3reNH*XLv*FrLo;sSisN2o(b}gaQIrfSSn9sPgvNvX!4?rkh|_& zWzJ1}B0 zJfne31vD75w59AqAG3|1FM^Fg`*uPw0dMAH1{r#~(iO{7&j^xgmY5@Q3YLgaI8^K# zZmzOh>ysUSt!o@}k`P{Jy}?blq&dw4)QIbcAqi5sh~Az8i8CFMe4Cp(&_`NyL<5px zLydUFryj}Bx=HC3SQQpUupaMO9h}K|-wG4I0sQz);zc@9&uy$btIh>!y(%c?sto%p z@hZ^9DZR$t?&PHH8PC%rbcR8MY%e(xn?MEWS0wXtkBVRcBcnUVEqefAK%T!5BDS^P z+GGKFxo_@Rb}wUcsGiod;sfCDgD`ec$B^P%Z)h**s|89UJ{>j~6QagYf>Y}N7_SfI zB<(i!t-a#4Y$MNsP*!YQyqWOaY~oM#`+QRXj&7)*XRaf3U=5HIQLGi0nAk7Hn5DGA z7Q0<=<3ZO|pfXM63qBjLvApDSDc;p;K1yDwjJjUB7|u|>t>EC-V|ZTUp zoUEgxVHrbgSG~Y@+_4D_ZIj^f39T@jIh=}RtlDA1b`i{to2-T;uLRg4wj<2WL3m9H zdVsR89dz}IKcl|+!czvR9W7Pw$`|USu*6h**9lsrZiZ;}MH7(xN+9^ecIH+jRP1o;2gQ3${bSh;U#)-D}-lj>B0H=?@Kq<7bXb2;HJQb4F~}Fio&es$n~RT|y38j+o+c2ZBoHx_phSW!ad)Y0%|#D7=fk(Q269}Eyk#-2{%3PK zsFh*M;XE##1m?4%VOEp-;1Oz1}tkEiol=-o<^dvOqmvLvz{wXnY-($5j2b!ylR?PDyviJ&-e9daW2z>gm*+fc))XR_un_7+=1|(b!&eujbyh%E{G;u<_%G^ z425P;i@Al1l%Tfo;|>Q;w9#A9Zp zRSK$iok*foJljmK4;6DJR|v(y898~ymtwJYU+)o)t_J9zl%~>V-cpl+_nunjj6OC$ zY9W+_FHp$HDsTEK-JLz~D2=ILV<8`vXzaCn5H1)EfWm@pW>^6escj!q^?|no1$)xR z-Th{(Lsp<DNFPQOidwr7XqVbsi4e;Nl8Kn= zP9*W-ujZaf;%o-?zM*9Q-6nym5Opjyc%wD-EIjauJyVJ{f_yEY*gWGQmj0vlp z5QMt3Bix;azk-n=UVk)POm^T40VoDTC?Bd|f_4^zmzNxS;|+jsQCJFb`#w+DgsLOz zU6y?u+(3msj6AbGj|ZcVaZuT2gspiLyHzI_jgM~*;#&xj>2|4yfQKKXd7e=xNMA<9 zV1w_-hYvfu5y{&s?O~US@}N*S-67*X1$hAx+PGzoVwxP->ruP)w22Gz1!Vf1(wmQic&a1@KxD@cx3D<4al8_6E;jLEmer#*VlR=O$ zkR4CRP>c_68!z3620Nu;!|&}DFr?ND!A^#JKvA{|yO-SwY+PxOK+US(1|6 zdbYD5>z7qYLpe**!%af1(Phw*LRmcBrAEa)lhFxr*+FML?#Y>)!qtGBnOsT%_!)aX z*~DQ7mSiH312X-5I05SEknGdza}+546)V?jmvLmM}$=f~;5x!r3R} z4gJuvvgBO8mHQ7HLX@e%73=ZSU~4bA#4u%ZdMt+&LUt~7iE~6@h+tuxB*U*fi-bJE z*wZ+oCaCS>H7LH3N-!NW2Pr`9xK?iT5k#!70B{vNIw8$~NgzRC%`*2MR2pPhVA>>u zb`Z?6+uEo?@AA40AcjBN=VAw2S~gEsx%dk9c48uJAX^P-tLn=(-z~k910`rj;CyD7_&-DxBn`uAJu$hZn-#7sw=t zb3OYIxcv-l#5~;s`wpZt%nf;ICzRWudx(@|rVBkO*y)!9ZwVu})qx%O-sJoTzD7-l z%T`Fneh!%n%doC^Hf!ifY-JYE!@M!m7n*H<6K=SD%XcSA^ix}rn^;fjF5 zR4-u-eXl)hBX}vvR`CfQw!lt$17fCs*^76qAn=-CITyUp+bI$tD3htSH!mWc)b6sA zz|yxiKI3fZdchU9AwaUZ^#RqHEkMfFyN#Lo*(CV({?lH}a23v+QQ+QH*o<}5eBG2_tOH)(6jQ-{T>nw65@83E*^3fRzq$e&1}V#=bit`S zZ>rr|k3LQGX1xuBFcEXTAg`eXB#c7X_mL4t&q`PZ(X(#*xkSKdPxPCpu|TY^(2p?E zu@MQku{cf~_*L`~j@rbR@qM6{k1C3qphJRTwZ(^C&OjeSxJI1a*-qA>d8FKl|Iod& zD_iA0JUI$&wtpeXob2?+DlG`mijsBBYF4Qy?$v=!Dx@hAa@M(xO%u#k@(M042H(&A z8@3FWQ=`pxIS~HH8blIf42y|&Y59P9C}U|kXFGMb>~H&Zzxqr=Lmds#KRs?SCcewK}+R}yAVepO%0Y@bn^JY-A-jIr;SkJAGR;K%g6I=0J~-NC97RCd$B6nU?pOgt`}jB) zTF3B#@nQG7A0%36K6^P{ZlFc8j66wz@ z0J}&Zyrd4i*a%;(%R5SnbU}m$tdD(P^BtJd7rH)6JbTbk=^NxD zK3Bs!QMgZfH1?>w1N(&F?Ko!&5#7P?o3Xv3owt|7KI!YND&2bvVq0r6JI_PIQaPBM= zI3Eh5-IwI7B;6eGac)lj5KN#Ce-tDgBL^F@Bnffd*uHHM%(?Jtt}alUV9gy5bLUF~ zREC}RY!f_3@HLrT$O{u=bA%s91{Lumq|^K$fulHQ*Zz=6z?^{D6Pe1r0rO_8=@6RI zpq1#DdbY>Fl?vGBmbJ+?8Y8t1f+~aN;VOCHgW&1+12Xp}-HFSA9v8$Si{TkY z=0|_DEYe+{SzuPSv{cY-UxfoXga}7A{Zpcr3(};GduHc17}wi>NEvc8KITspYW`kGHmGAA@yB8O(P2JZXAXUtW%kBgj_m zB&38|YU`QRq_hX1!T{~E9)7KTWCl>Fti^PQ@WwU5`WEeEi3Lq`BS;Lr@M+|Y&@EZ9 z&Amq{(y{VQr*>r&X03OnrzM49qJ&|Zqi<*u9W48!xA5$$vH^Qy!x%&gG#({|U4j7x z%2VqC(t^8&kaj$*HiQlF#aK+vdsNU13K$Ak5L6K(t7VFn7j8ln%z9s_V6qA5QSK@z zMmF)vZy%8%Gxq?N+k*leFv(Es_{=sdHkRdm7Itd&4#6Bz$vTJ$78nD(ZZ*6>ek`P(Byh8ta@6vI(b-*7Uelh>U*ey{(!)SuES@qdw8Xkm8q7tn9mE z#Of78N<%8jHlDq;k&y%DpNk+c5I^A)h?H$%4>8%hDGCynN+3stI_id@1KZ+RZ|D~i309#o-)n-107ycw zoD4)z3J1%B4GOdKCJ*{_E^8!4Xb^walW|!oIBP1)4L}MwIJj`>%UAN!{w#I+N~4g$Yy26y6l)3-UL)q?<*7+}>&IW;?!J$1b9w>Qk`BOeHZ27>&k zqL3Iy!pBllKId>j_J#6;LS^)F8&U5DzzZR2pM?a?(F<}r$9zZd(THTr%lEKT10}g# ztwQ$XoPmDvPOS#L6u*?#2yi|T=2293eHL* zme}ZTJT;oxn%d`v9M$dm20 zGU7)^-(U~13E((2_MGj^r-^6UFuRbhG>WFn8{6vu*~guT+O^f&Rx~t4h2)9R_$%7^ zz-vO5gqCe6r6OPVQ_mBOAw|O4JQ<_=A#1nEFgzgv)?!Nhi~slU{pLU4-+X<3_xqCY{=pP=YZQ1mA#`V$oW35xy% zMSp^#KS9x-pyL4g-?O>r$G8sApL6+ zNdJran}2qG_npV@^Zd$IHJ^KuU&)^2b4l^Jr1)`3@wp-R+z@xlg?Qj0+H{X8P z82*<({qFbYO~!jO+gQ8&jB?|(F>@4%3cztMpCvf}0XPbXz9`VVlX!>Za9(QZm}LYRQUT6Z=2Q%=AF0l8560cb*D;E{PKdgE z;;AGf*z>MNO$c+-9}6G4vNEYGPJrEAR+&5d-b4efGv~JYG%t0XV(oy#+@%V zbgl9%%91{bU?Q54NFF_;BZAk*&0VidoQ8GJ5!K3`HWxFeYj-*xp-HfF;S000W+N)@ zw9qr*dq_U%|!^ddU6?5}6>w3(QtgkH^WqZAr zDkQP1HAa-Du6;H!6&Ip;C9DelJE0Y2`(TVb9{tvhOvu^YVxIacIm@2!+V~Z$t3I7Y zpBuA(4{&HuoGx?DRobLLpUHNt264=L4?fS(c`73l>M4d}`x^Tw!(PdnB=z#i+@xEs zcKdZErIe8MAtHp(fxX&o1dW`>k)m&WA4e0}ALs8La(p^OE7O%(jrxD=ZN=#+fRp>Ac;x<15w4~i3gp5I$rZXHp zd!(JS+bP+I1YHmPZRJ!S74~A`_7`-X5b1seFyw&^VV9HGwh~3)!m-plTFzVE1IMP`g&+jNNW0$yN`z@HsXh zaQGl376Sj0dw(4n7{7wtgI_^@TCb}TG+cXz&ibft*W0S4gcd{w0p6%+UDxc6uJ;82 zNV1jM*&nrUHSp_I`f;m-b1P{K#j-ZYK|@!I7dJXrJMEI@d&&@9`Rhmm`BYnds;xdP z;h%!9Pr=ux;OkTH^(pxJ6nuROzCHzCpMtNygMzPLK^nDsXFa9k_-e7{y0;ec+vso$ z6Yj!6E2Q!svX@a|RB2YrnTu-09yO2&l5rt~+19bD+96kdbQ@9l78V^Oqp=i9BHlsI zw(*%p{X-fxhhIrlIZ2vub+1G2w!U0OG}$mr{e;BQH;W#igT$F0I_p5M%eRaZ>J8aR(tCa z=rWcoF*9}Ckc6Ac_p>;&rf!U2iVJZCKFtE3W`R$$z~2$G07p|yy6AS;vszI* zFN2e{W1+yYhB&J(8ME$Q_f;W@Qs+^->0P$$ zy?PLDpEFJ8JRD70wv?FU#K=C&uiwptwkF9xy^wFu^G$x?Ng3~2P#^Jr$~xuj-I2B} zZeD7KdQa!L=9he zkD;{@tU|yHc~n$T1HpKPl{=kgpN=s3i+%8^nsMBv++L)qjMx8K-p>j^C~HBVr}qo9E}nD-l{V;*U^gz zi_%%6-N8TWWqWU(t<?nH^q=r1fr>3^)ClSGVzj|ld*zBur;c)G(9UtX1 zHsfnm*?mlV!8Fx;^a;XV^AkM{`c) zXdg+qw znE84|UB1t=Z1m^YSxB8>9X*3D8J?d~Q3S>6Z_E*$bi32)C6ex_ZksmI z!YbZ6605V?X3Ei%l63f0CRpPL3AE*QCM<2LkYI-h*_e5K2tVItedyS|8Z${fx7uxe zSjC!EHdj-}cY^j#!)$F;sTOB%$vm~Og|BkksAZN)s?SnJ0*(A6yTrGZn60y!zhu+Z zs+6~D)l_?#Sx4GD!?!G#X(QT*MbMrQ3~OYHu`}vp?_#IXFde688hdw!pQ+{U%h%sp zvyt~cA^6gMvW?tweO*Q-Z1)kAD^Z1#Ww3TLd%LNlt1tr#t(M8Fb1cB1MNDmwGpD-!}* zuv!-@wRyrPezM*B+((yo1V<%Z1JBTX~P?%7}mf)NX zG}3D^;#iscBMFTkF;_FiYqRE?n>L+VNVS`?mN{#o)ThRpGg5kA=TO76X}0uz9M|>2 zcd`0FwOXTbjr0|LaK+YE%ixq>NAKj!PO|Jw8zK=l%pA3enCYIGKweb&J&-WLlrqP7clV{Eox z5-UoxySmMOq)&@i(3Mk8&pLaVC~EG$<&N5#7#XT_Wkc0h&a>;_A}eFE#yG8KJ*O?M z0D==Qas<*Z>kaJ%L92|mY|Ng#x=Cq1l$^vmWQQr&r%Ag_eQPJ2TiVETHohqv3@z9^ zcAJao$>keCNTZ%**L$ow7;vRdd+-^=jtp{&vOhhI`qS* zsW8J5)N7*_X`Gp?gwQ~CW{HSVbLuX4Rdh3}9@5~N41$I?tDmTy8@|7i67g}JrL;-? z7K=PNRx*eYb7xyjNzk%5A8VyZk+WHY?NJxYf@P8VHi}ixMk-zBDOvBdg$!Tc+j9&> zebs_wq7X!w?L?OsKFK%vsh>}sGwfCx-1M%O*@%$d`sxK|(L8l#wZ^(bV%@qU2qyR3 zBO|0TJ-DHkKdn!A@ZiA5cAA+i``+#dv?FOwAqaauno&t2v2 zH(!WFlWd)Hs8@-CHfX+g$w)}m%{(<)M`5`!TuxRR_za#mI=9YP^s*I^QDYq^>;{N$ zW@v&GPE1~vj|;jK%}t=LxIg#UkQ?mArm-y8IkmQw#$-)S8tN$yt?{mAHZ_R`+EbAk`*IYN#g05vfT7TcGh1oe z&e}EGz5EDhh(ucu`>ZwZe)FRqd$xO*pzlGp*M_Xl55xX*Df-B2&&?93Xmu+ku-PfH zFKa`ZnLTT9W$@F7T_Wm-&F0=O13SKN&q?TAx75-4QXDj=#-gn9s+Z{~MbUA#$s08x zzL7qb?OLR)I}4Nba(vg_Mnxc4<GA(PjiomUhgabq>jvmg_ht*osTM&#be#h>_!t zi-fk+6+$mB%qj0`>={fkhm2wf!e91lQ;5M&MF*?DNGXQVepF<_S%|W`#?brFTtyC z7lL|oT^o4eFB66LB1CPpBD7aq#`FOPp)8m&Phc4Tp)>RU2t-)}u; z88UD_)T?NLim)riv6GWw(&l4K!Y|9xhOo3d9;}gk&uSieavilFIdP&4_J<%8^o${A z#+96R`>xh^-*fQ6+ZE%oz9{G%*Y{-Gcki$gYw(9JTJIxT2k!W&TzLz9UHYZw?pVN% zb`7q>tG2lnuj}3u&HRy@9e0}{sJ=sdg-o=$*gB&1!q1WItx6Bqlogq~pg`HXUhC|w ziV0r`_bimsd%+{Hbw*$NKL1M18EwubmW=H4DNTm7Icnk+xW<7ly}PD!u3zy@Rwh{>A_EpZw;ZfA{@2f6Vj0=6Cy#zxx)n|9}5x zf#ygWz&6yo-Q4(b5K;F-*MH@m`YEUf$ASgGeNX&#V~PPyaoxkHeOwaXnDqfB5+9rHN$diH+7edF4G z^Jm}fZ@$gn{KJ!fz5nh0eg5X}f9-$B-~9O>_P4+Nn{WR3SNX@^{L}OAAK?!_^)LMp zfAeR5^soO-{^lR^6Mpxt@BEiv{ojA~bhaq1Sc^NUqV*Vd2L*9O=tUb!@w=gqh`szyx;%6`HyZhQz`)RTbLKAD5vG3`(eerf}J*0tN z+#0jg^kY|2X&hUxbK%l4Y|vUmDyQ7mR_dg2*QU~DK}oS&)>#*t5U!l-wLSn4P6#|s z7HqpmGcSv=_`v$vvi$gV|9t=cn?IfVd;jB)@Atp_c(>pE_8b4x_ka1@Z~yqsU;pm> z?7RM@AL)`q_7DH^Uze}SSN*-}E`y$KXtcbx4OQ{fy)ke@PqM_Lvs4BZ565iV zYi$%4xI!uenrd^0pu85odtBIRg(b{fYi4yc{|uB62rJF+4JPoj$NJ(`Yw`v3dRf$u zDVr_>|FB%X;aZdV|E;kzPU@<0N-MKVlvOBcw#tc|$;yWl0Kc2@gQ-C@spCl`=RDEE zPvFR#r;e>d3b>aaUiE+Rhi^{)et+}z_xXQ*|Lq^Y`Tm>z&F_DB>Hq0>=dXU|4gb%q<>Z3E8fBOSKEUZNVCXTJMddE_k%rkQnK&b5;ewUDp=)4g|EVt_yVKb zU>h#(z$KZ5KJ?~z>d)=_q(_6IRHWHCRO#HaQFg0eyy9tH%k6WAJ4+;>7Fo0@UYZ+R zX8mHW88Nqa5O>1Z#0o0ew#9lEG{*>d3%ECb_iB_-S=vS)t>4*hLB&6_be-!iMVy9H z`o~xNXW#$ZZ}Yn!-s#`}`kRwK^HP85XZPbv{fqZfYx}BvB_D6Kz>wnDxB>`|DsMP- zBqA>ShiU_dNKO>CHutS(&AA#lGS)hrI;Nv_bnqdKEWnNnZubExi&((igFRtGD_9retKaH zytMn|?_^Hi8vll#Qp2~Wsm~cL`*t%cQtuCMwfyit|AGIT{QCRve&&t-($DRuZ?wD@ z`okOD6ERf5kdGjc6QC?<=cdRiv8QIu-iBJ6EDy8Vtyvx2UR%p5l!dEl&zXx!&DiQ8 zEr{m~yKr`3vs4tvHv@lo#k;+V<`-|YIg;$n)|zixFE&x0vRG<;wQe>cOnMm-@M^}v zGH#wwk$R`C*mp}iIyWT3@KXBBqfyJ*JkV`4P(V=-iU!45%;9Y?XSFZh=->a#Z@&KK z=icWp{M3GWv9_<~SM9yc)l|=IaRRwr(9y{nI}Yv?)qzK`Sto0sHB7%8k^xU{;n&Yckj<||f)k{NUL-~}g0^-YX zliFC$j{Y36aj*9;UguxD`nUZ}hJX9JpL?yp@YDP0msG#%KUBY~&sB}JZ}D=0Pc?k? zM`ifkdykXQa#ozlnr?ed%h_e!cJtJ+piDySLn~LunhZS|Qlhr)Zb0PV$XMAb7nyK9 zi{E!Xg|B?^Rw?PNTttVhXBid~$9!XUuB{X-2^^%Y?9F+!QD4lPwTeax`mFs{LbcaB zqy>zqS`R#@Iq+N~k+Fg9TgN%7l`#fl)+IW=yhQ)}RY>nm{@gqLg`eGz@AO}N>)-Fc z{FndXXZ@eQ{`L?5jsB~D-M^Y&>3{treEGkMKmG3a-~aCG|6zaghj0D+|L#Bh`~TDX zD2#|%6fCo0H`Lk>L)x=#Spy;mFKrc&4w=XWl2$_bFm4cVP)|BOL3Dnz=No)^n-Eg^ zajyPuQ~`cUvxPB*$?Rq>TE_T~8Xf%r=N!f;v#-3~0{cDK|$O)cnh&UD zweao0mjK9&1qRyB6?YZzxY7Zd`WSRfiIO=DVBQ(M9iTDoO@Y^!x9>mv8y@!Wf3~&# zrJvkS&+PV9tv@tA{ZdZj{hrzjni6G9p-a)>h8D8U2HLfZGt~}8*rwc2xQ}!lrM)=clF+PJvUNDWxFY-8;0Db8nJq9 zY)lqf=X%O|+*Th00%pUoow|3wIF47@I5ki?9zo-SCyBYnJ`_LLN@Q1S=W0JTVEKuB z@k;;G|LdFcb8YM|{Lp^-HubC8zN#N@Ge&nUs7Kc=V~-P{mePIQNZ;iasU30IlK#Pz zRIQWEPbRxvTz9qaTZ@FQ1k*B>hDAUL&C?y^%{IO=Eq6+S9Msx%BLDcid{+O`&+e!9 z?>m^^J8eGVUEBfX1qvY?8ywXvc)$%Z|67pMJsiz`f zxXu7Hsb`?tYqeb-*8q6{0_Fvd!}H5SR|Fx1*%@-MpwRezi(r&iya0L3`jQex~n|}|8(S{9jw5pvTPd5Oj}cIL5_~YH)-@fbX1Ud zu72;A<@4X=;qfp0B>$t~v3~W@_lDPA+ITugf0KdnBtaFK@Rf}u`oyE^?8?9BrQLRr z(lyAmGj-wa1bPKSOD6ynl~(1JV|9!zA9mQ?uk{|1-O(CS3fUcBykg8W<pv^8nzm4g+;`ttdIG6Xj4vCciH8 zW=O@67$BE^@x}dn{&U^#Fa6BEEQs|h8SiCIfJBJIdk3~#^9bWf_RGUmC0q((h}9qD z3@yniw(u(kq^1Jku}|4|8N9O-TckEAN>_(|A3u;6ynnOUz~DOw`e?O{B46(HGVvBT zfRPUJomrrVAZ$gHHcE=xmQgaY)&^j@#l<+e!)oJ_E0ZtjI&?- z%~%#nGDWex{g^2xj2!XB%ls$%kKcU#+wb;Y=K0g_e{MMSOFzCZtElqBs1Ymi9Ea`i zKye5T8K)5xW^~b_^J6i>Mg$0%pgsosCW>|@dRj;P4CmA>VBaeFF>5ruek}y#ecock zp=^7iI|jFgW8=#{r(fe7h1QmF&Ml_^>Sw>c%7rG#n!UqVhT;bSKgaFw2i>b;&D7G| z$S!Hu9A|F3A&9T`Mm&-QY+tz`rGW2|KQwHPVZF$gv#EdZwSWE1?|!b;`K6!Rm+w=4 zm`XKKToI`J3D_u{+|A;kHNuB)axlX!1s`||5g9(N9k}ZzU4c35GYbhf+j87wr)Ywq z17#=w@j%VEPq|n#4J76$s*yIvm!spJxM-LQcEQ3GdXe}ZM6AQa(HYFsZqX_d#bH6D z&EvOZCy__x`ExMBh2871TT$FC?0xWo657OhSi|2)4bFM6;fe7(Y`Q}XYHSFWy<#Wx@%4Wu>4|muH#-X7=Rs3<@?o^PUhk%QmG#KdhjdTdW zY9~i45UD1CD+)=K>^Q;UEDZLH)(+Wc6|)^NM>Xr-;lrhfAjW z;4q4FYj=%280RHxh2b@jgv2=u^26Bs)|w?xTvjeHoq&?bly#yUXQ6vX_y|%fV1pdr z8*f?s?c<1l_E&%XTmSC6{QkFp>0h6p9}EA|5A!Eq+45EUp=bT26aT(=$K^0LAXBbm z*wd%q>uQzw7#`ZG6XB~P=PDo8T>x3Fj5}AG>UcOocdUElj$)o9NW!Z_BR2&}QccCo zxh}Y?$|n5oZqjT0+u!kD{ORlb`mcZc?H}{IpFNU)=?D3f_glYeKQycYD|d=IW|q=O z<8o4cPMP)b&F}|1V4LL*IbCf#mH_M4$lcqg9GR!t^L4;D8)qxT&qk~RWP+xPfR?f@ zIgK?pLP3GFZC_5BCb5hcPhnA?4u=wKr#&p9-I&|ZC``t@Fslt{D8Ad}*=~?w0#?@# zoQMg#>5Yfk=j-<6tmITsBi)z$v1QXr8Q*~UBersP1 zE4A#D=0)rk2L#|D((a(f_kQt&efKZlX(UMIbG_ofx%?JZ>-M_E>YRAIwZTG}hNHCB z=NlT`6Sn7!DtkQB?@^ow?KUK0AkYe_L1qnS?$UaS78~n%v~%%2ipcV1LHwWPckDKQ zw!`^_AKXtmoWf1}Q8!`dAqtNxJjpY$)vm}fGiT=3x8BvUrV@}~Cw0d<$hr~Q-K$06 zNY!xs%SM#RAgQ#IJ0&te&5ExQj|#4PoKi5Oiq!W;BMaZG@0ktb^m08R0+z{abhLKmOYv8~5D@ej5@b zdd%CR`pi84A9wH8Ye$lt?E#i%G@6k#pY+Kv;44A*yAgSaJOH-;OJrnZH)q(~G!Jv| zuQ#6BWJ|sFV#9X}<4d)qZnA1sRc7S-K2K~Tc}+iCbJ^2+b)8p+8)h&Z#|pn`5op)fTPpv~a(Q9vc)%PhPnec!79| z*%?x4hMbVwHEbN#f!knl9x2knx=PYy8w5K{Q_`6ScNJi6z^t517A8O$IIP~* z2i!Vc4h+MP0TmU}KDG4Ph-+5c7yaKXhqnzhspZA6u8{eq7M(I$Pjn8Ka8M9vEG}GW zgM)?$x!xY5$)JFke50vxeXxcn@GqWe%v4L*1a>}dCE=!TPkW^}?Tn-?ZxtAAQ3R32&-4&2&DVjHbQBK*1 zU&^+`$RJih7gA3n-AgmJL5J6?hh|IzKy;T;6nXhx%|Ko<9=Tmv{pwmS-;2jQ__BSy zo4G1J4g)}QrZ!Uvg?RAurIMr4KGFb~MZE&W8 z7O-3-{i|4466n6&bEmC>fvVQsiyn3zh0b0-bn-U6=-U$k?07)oa&%jL;*o@JT1LBI z-b+&_MPC;aLr=I-kZ<;mCbXRj0zq_CD}w;}F51DynUsq%W$K)EpOs93VCOYTbeuq; zv!8l9l=_F4Q}=r-t4CkBpS^+8f4zZU9#vwV(7y>>7R+|Gq9IvYvp0nmRn0qXi;Wp- z%z$U$8EFe;{|bJ3tfZ$FXz!ib_k`IN$D3gGn%L$zR7FIo33$fEG;17009Zh$zy0m5 zuO5Bnety(`EvH@!D09J@vXZDq;I2uix7el6l&ZJsrxBc|7Wu0;(9Ki9TzLr#D1&mZo+aUXrvettLecjL?5OfII)Wb}$j0)gm7Ann6! zZp{_tE!G3_a4D@zie%Q+&t=<4XmCtnaG>-wc-6`DWTb(IR*eppA;)UI{IcaVKq#wM z*)eX1P6GG>XZz7K-0Pa`WDqMHb?{D=x)R-~6;;4T)>29xX1w}V9g@ci-P)5rJr=Xdu8i4VSbKfkH{zv|A# zmcf(?Xz8bC3B2+nUiQJ74J;M=teW{^fZ)aCaZT*7HDuU-GNG;P?zyD8N}jc;YbLBv zlFyXp1qvhyEchsRqvpmj$n9qo9G5rI)M_4VIKp!*A7~}ue%p>po8<_RHX9S`>E0}t zRQiSMq!m#OmPxLM?=X5-koYK>z(JqvD$>|v@K9xDv52hajGLSKZ!gQD=g%KJp5EJs zk9QAt9(@gO%RKV+WCtn@Ut{WHkVFLlvX+Xta%`DRrH<%5ChFKZFsg1py5V{aa7<@* zWr5Q0IHg7+q?V|(E%dDEkd;~>AUI=e*nuPkd%cLsw_}HNs3o;j1(otQp0eyKZ&Mn3gTuv0Wp?*USXL+#_q#UXQhtXQR-{SxEwuU+V;i ze%s*q-G95c_r9qQzId;1YW{MZv*Xb9suRD>Imv3_mkm;Nw`*!1b?X+`KlQ9ijBd!V zi{;WVb|J;87b_mCL8k**YiL<%A_9ttip_iVUZeVTL_WrZdX;V;*g1-?OY^d89z1Q3 zd1$|`1>qa-buyhU;2VvvX<=Xsh}qgqT`+V=im`F$EH4~&`rLI119~iay8%o#7@P3k zBv#fIRIFTHJ+Ob_eD34Z2m2IHZ{Pg*=H5x&qp#uZ%lIcSfx!VhQ*<$vD!>mcP&kx% ziuJ+%nRmx9Yl;pS?scCBvp8CzfuCHw!LA;s%z6oV*A*KaO`TC?uLHJV1dE!w8<;8- z#eLr9oG{ly6{84YZ6B<7SiP^a9?A?bnU=_?dBLcvYi|C{OvsT21Z-hYZDh!+j*%}@ zfnha(-KU}lsZnfXq7&_bvO$5=GUlsn=|6nAxA*on5591(gNW%%onzX(R#*cpc|mmL zz`Ov>9l0!A4M#>Y8e@^_w9FNAK@+9?oM2jTmAuNR$_Rm5Sk&Qp?3&~s;-TIX&v3fzkhn5n_kcd}KgVvZZ;7>%q9YFls z|MR>#q4~qdFM;qM?cNCZ!PoFkQ}X3CoV_N>u_sR(Wz%LsjF*bm&QsDcf^bL)DK2(7 zJtle_yry!zLxJ6yjPppqIiYs4INglQrVs#FQX+2zTzg^NU_KTl?Yz}q%_06KQi+eg zXs_;O`EI;Cssv1&bkOAvtgEpx9@yt?oN{5k3zE$4QujIoLOdo|KQf0`@1T3p3j>vc zn$xlT;wGO9Ktdwq>}9H~Iz#k2mq?eYP^{dRtjMSVhsu{#1DTBz3ef{qi8Y&mZ>nn;3VE z^+}!bXL4WzgQZK1bW88IGxSY~MYv zt{&s`Jz;xKLn3lcJ)Sce&)cElk8ggww^DlaRr}U=bVD?5)`CAVs#LV7T7n{vnm=uQwVixV=OCo=iy)q1|1VE9i)9WyWDDrD2Tl~yVi zxGH^PGMmm>IXRID`J>PpAI$^Wd>^;3-rqo3d;0#b_d*YkzH&diqi^j~eEjs1dN@bw zEEtnRbrZ7fBGk8zW=smGWlC->!G_aZylj7iE=Gj97@KlM~@}S(|s#i&?X60h|fwNzstU~KnQRKm=r#({!8@c!Jx^(HDG}EIuOYP)3f{eU75%C`RT1cLe z3?U=OwsaRsm!CyuCM$c=TnwNe$;O3#U%-Tm^z*nWK z7ib8TJ#5aK4^;*{pArb}ZS{=gW|$>gTP?G9pWx?r!Ogs~h%vSkZMg3?LFF?%Ut8^B z)$?E+%}}&Q8kFeETs|6+FFP(rkl81W%5feM+LtSCN#n#Rs2X1nytiq2tW2#Tdn zTCaf1fxkd_23N>rAd)vh+kuFiw%rDswXXTyZk;fok}^sOZt9pD1WUeuUw`!>%g^=2mjbug=V|_ zbb539w0?f`&A0HQFW~DN`|^?Po4C)G4Z5BbLQ9GaLl7|c2G+n=j+94?2AOa>)Je2g z$1ttS4mzlHb}g9|I$YIL6ZXnINv<1qqTQT7clM;S_mlVT^UQObT*}%@3^Qx|Mr+T# zmjv_SYRv33lhCSDn6E1tO8Jg^PrCAGLgb#OoFs`XQKFO(9kp!+HzNSt zdH2FAF0BFA?CXvF=jZqF?o+&tALG-9zy6eCx{FVI^d-D`5znui9UDOdM6cwCw?p;k z5c@)1%He%6I^N!psrbpwZLP)+N0auT3lExskjYsEBMa_7wr_3PT+?_hBF$#O&Wc5r zHxgk5GRy6_-^pTz(N!@c4usVn{LP+o18+;7ggniBUuuMfU_HwDS|73u>) zkVy+&qcoEOW4N-ngKB2TIZF^UEn`qna;8Gf3u9l|q1xMIB{F9KJ*t>82-MAWvL+Zi zrO23*zjiXc{Mj6pZE|(~8biF8_}VIcw23%{F;2ZAENo3uvo+%!PM9xtuMZk7sRZ_E ztkG1)hO*DtH47AIckBp{*x(am$)xH%pof zZOu_+4CFpXErC%~WDTfRNLpjAaaP_lz?c{^o_;$*#BjT(5IHd4!oUTH_Z8vZn;pF) zP6h}OjiXiy8<(0JGF_xPMo3L#df#nctH<4h8<`WCh|{WKo^LDFjQwLN;)G1XA?B+Q z;@|(tKHNLIdGuBL`JMbS+8@IwMp7{GQ_>lE?!mAHU8x{Pvsjp|t@?&$At&hm3}K{# z4gy|OHmFj}ea7Hqa8sqAM_uxs=fJ?4v`AYWqb2~^nkUe#TZqKjN#MkJopz=Op1EcS zZXt%05&V~D%x)rrgJ$==UT7iYY?CqiZQw#|Cb~+>lza|fa4C+a96&Vb$P~Nk)P0HZ>h3;$22yS`m6l|+>A7V& z8H4>*`D(Q;&E(WYqb8kmDCM)h44qU=_9I}Gq~%JEVJ@I7J|z1HumHDfULkVnm01GA z6iyk{YKQg5Fo*{hROFnK`WainjBDrY3;13{Q>+G^ZU!y{1ZZn}LR~TRP~cztSl>pe zd*-tydxv=`#9F!yjQ&IX<>T|)KiwPuKKjDFP5{5$(56jsg4J>mw}vl;nArjM@c;y- zRu46xxR!nHbk4{+TW42XS&}fBr4<~jct6``u%!oU0!p9v7>iJ`X_!y1B6(h^WwBS# z_oHnBQCNeBcCH3sd)bLv37W;|{Pc%m4HC4}ZH>ALFq8!Go2J8nqK0&jn)iV>;Wai~ z6cQoQ6sl?3on!ccCGg_^vJ#uODg9qP|G=N?&Ytwam+j|gZ~4Ed@4b~)FD?ujM!l@J zw!3);O_DjMZ?$y%)OJy4woK~{mYboxTt!aC_)=MVm9q!kG3ZAzNs_->!v{O>|%NI%JD<1U_`>c_d85nZjY2qpzgPk~V|}bLG5BKN9QefhL5j zX%^c2!nsEplopT?hYbYJJPy6B#-^@Hhv&~HsrGt%KWQ@FdpsX~*={4<@?~-~GB8XG z#5QY|8gtJ!dbGY6tIZ91yxQt%SJkLv8D}9^mU^Zj1ZD2j-Ba#m<^Z5_)xR3Eyj*>h z(~$9yzGyal9ux&*j&ee7Bi;NCV?v)S{N*H^sr!+}nB-o9`D?(?}P*m(3syM5QT zuPKLBO!GcLW!qZaq}JiARjBd0h-DF#X+?QM5UJ4ygqdb2jK{imkqMynq(ZwVnH_I< zUQTIakb#wTsXGCa2ve@wXt1@s<8~=DOSswrkd3NKmt6kPnIJ6ew&`MIC*zs?(7(-v z0mN>X&LXN5e*B>F_7Nfz31)U@)>cfSE-jfkAvJ%iIj5xtN{cgsZu<48?GDK0U%#{% zpSFGY^P6{1t=?NAJ@{(=a-R|Zo|mm4M$$f~v=!Tv<-wVcmEuVbJ@!WSXI`F9uk-r9 zLn?GyI3iZY8jf)pwx9+5wKNMpUo?zIb#W--ygcm;d^A&}ydLFa7;iOFI&pTTXH7p` zpa7SYJzwtV+#-6P)&iBf7c|6aEP`GgI7ne!?hWGfm`RhiJsXb3GQuKrw$4BEjszBP zLjmFxv;V@q{`Z@EZ6AKTd%GWfL4Wyn*PPX2v!z5FqEU$ouBC zQC)P>hF%F)P6XC~+%1!cS>_=}8`+iF55PnU__e@rO_E*cNfxvPA+0nc`=?qhb7FF$ z_6l5Y=jvt9X=ioSzkR#^$Jg8a_RYJ`f4To;Kl)<+@~xf~y_)4~NP}7x!R5+wuocyI z_E3IA?Rb{bOD_3TV86|K^(`)?4Z$QrF)Xx|ygDrrN&Qm2^Uuc0r{!6Q+3k#JEsZN( zkY9}^=IOrm7-3rAT6I??D$0_Q)|Fdu#91%K#}22?%xAcf+B_p2tm7xnXp7iTI^Ngz zauOn2LU64!+iP?!YgXMkYD0K4+sVK97XP0=zt!J*upfOrfB9}(n_{)iM*mk+6P&=Q z$mqG$Sy`;eNI1g{%Ifq{dg(~o_JmOHyByC>HG9e=jWiEt&EA&Ll`+b}aXii1T8*7j zB%jO}NbL$peSskUSPeF#gbK*HYdpDo>OBIbM3KKb%m4`b==KgZd6peGjG4^h8`v3A4xJ*hMII&2j!2#POD>fG zQ#m`*3UKpdZ#BqBFx zBimrgo>MV4PaB13sND_|X^e^~U%M+DBKnF|Lr->H|1XFV{gbHt~hSmaELcS|{I7 z+8olmpl!o2ZKKRMErTQ^Inc>q%?#rKo#xyLRxrlqK93;y!%)XyfA+}bHd0|Ml#K6Y z?rR)+4xoL(LO83|y-N)@v|t^U7IIFx=v1d@_7ua5f;p>Ugu_#ajisZFxiQa&BAXk9 z;+qmkTe#H|0XoliZa2oi`tuKO?w;U1`m(*goiAJCQLXj4t&EUR2OetDc3VT{h5{g` zpE0{SWqY)%yH!EUcNMGIvQZMti)jiww|Oj$t-h8s2riMqLmw}(Hl-9K_1E~cO#tAx z2eVDYvs+3%U;gX1FnNdes<{Hr;SBc7VnT`E(_qA)PMq(QdUV9p0ZEh+$3XIEq|am5 z)~g9Bu|A?GWQjbcw{a40hSDthzU^WC{@BM)PdnoMQ~ckb?Os^?(HHRb3;2tTqpFA! zv7_)cH{b+xyPUj)V1qEEj_n+xbPm=ms%5mQbQAWO7p`ODZNkdCmhA&ithA}75~~&F zPeWQc)vv$8;!o~poNc%J;JA|Xr)%A@9g4^WanVYEbDu%Vt4y-pTF%j?_%=G{tS8qr z_9!~Z4C-D^_9%l;Q}{^6M@gEUxN0yPRDX`?wM89s`7VT6Z*J`We%;uY(#|JaZ{z9X zrw?!5egEd%`^Y}}T7K(Yd?pD#`XXB4(x7YgHKh}^ho{?`Eq-w!o3d@n6|%!leL~&2 zs-Sxp=^bh2#a}O3FO12^V)-m>riFJ&p85K!1=E{T$o$Lg8aZ30%AMLgY3!9-kmxgY zzY3vLzSp*%&RCWz247pL+o}v~X-ggw_vHTU)YQxAEzKAeK~dhaF1Jp*{J(2$W!U9R zM|R#9e&*&L|NDRIWIcWQV1J4acSW*~zKXYXkFVXVbJYu!dJA8qAQ-pcLB*Ds&0jAh?7JX$oDGV@o>I8yo+<^+iIN z$7DshI7-@c)M=?<%#&R%0MN|iHeK=S&mZ1A{oyVp=E2wPR`dLob(zN+tm zdoYd>4I-TB?b8a?)t09?t7anc(occeN!lxI+l*+$>5886{9p5`BO+OLy?rD9YW?-oU8C8fFWb+uPkdir?q=aQ zMG%rl&=KAAcMU9iTTH84m4iCac(emDM znX>1&@Ptcpn$>+Ch2Kmp#;g#*`_@}4RN)rvasP{N|nXH*+>byxb zi)8n8I84inb4r~%Bf4FU^fN7^Wp0)NE->Sk+ci^XXQ`TPh*4YfF$#@fs2rtsAz{1n zfrbb=zemZXm4bMtv|c$g0iS3!3sBlsoHD?yh1*9ApA3}9*?pzSUtLqnj#M-y)qabG z`RyBje)p%Rw{Je(t=T>J+P#V>zMSLc*x3;HFmYwX5-t`l8q+rCi#wA572=+oy|HB0 z=1b@5CrQ@K$Rk$@}x1apTT&PHpCF@oMXdIGDQY@}Rs=K#G^PPLw1 znSB+Z{JA7l5JS>cg=AZa6{z(MpQ>XYs&wcsUf}HI5Nd1`Q)5-=k!)Bs^~%WUMBk+s zSPh8767$A2na24@t>wahkmaiGTM+o~ewjk>=!^Gyq5B2y1CN#5LCaUwa}DeIlsbVB`m?3YJ#YwDB#}2+C$FSXrqgdXrtSN+o`4O6s39R za9zeNGh{+9Dlw1?)wco)ALCrd5dY^i3kVW$Yh-L$mI zo=bgGI9?b~o1RzDeiSHW=Q4&LyKtcE^3mkFz~(66Uiv#7AbuHLQmEIX9LOY6tJ^ri z?NL_4%~6#Vzl4j_dYLanH#$WCxq8@zNzBO#kqu{R707qMU5wTSg-e1(v9{=C)EexfuZ)Z3*|eXkXHb0+5eK}=+S@1PUHIZNwYr!a zy2&jAj&B<4GU08A%!A1FS$hv#6zdyRUemRTWgvZ(-uHAhOb ztu=7v>TOcO7%P-0(5JBN5v|sARx0PLl{6j5R&hA)7&@^V)Xco?bl_{gJE4dM?3FzY zu>WD6(%vyzHm6OVs??DwV0f@^XBoX3|J(YLobFdI()2HR82VOEKT^1Q`d01g(bw@- zwJqP37bv)cRLt6UD(P_iHClt89(C0$V}Z-AV?~=Yjj4y9WYi%hC%Sa6Q&iX1WqHk0 zmJ?A6N~^q~Lg`8t< zrU@8APgN#ujUKabi;d7oB~O=OU%?SKo%vh zMlogUO#9fjxQr)ykiO9V8Y%_&isXt+nkZ53$hlUF^NR5<`$+1Jrfh__BohNesbXGc zpPE*jI?YFgv&Dzz%#%{ICRV!SlgjQ>$LyP_`jL5%QA*F;{!?V`)$&ejsN<77)z*Oh z%6YW6o7?&S6doy z#HDIc80HzAx~FkzFa}2=vrLY&8$uDC4FIp@3Zl?bnblXd+c$A>zJ4JqNlOOm-mPJt zZUrAXqLa`uCP$1yot@x8iV8|XC$R_Ggwu5OdYyozjYtRXH@2u=b;CZa)#qupyhWQq z#8EKh?w?Xj|L7mzKY#M){ZokP3m4``d;j$D^ZWPDAMODO9(^@$W=!MDLCro=n2)cc zzB4}wFI>7adyvZID1QMNGK}BbmQ()Q)UoW;weSOwG z{j33zd9)fm=P;@=WG84810zJB6gIRM82)MOSh*aehT*qduHTwJe|Y!w=lieZM_;?2 z-O}-sLuGqyr=^-{g=)$@q{`udmrZ>Q6_-VsNcf-^l!vY2r1jnQoXT&qfiRNF^|}=C z#9c$1#7UGWg8}qn@+@jXjitC@_wPo%OGP(DBrH!+mSY@0{%_$#d zeFe<$7~_=7_LdGo^17F8C40UTnvI^x`dYh24^}g4=_d3YZD**jSG;jq*|)d!SJy4Q zcQ+q=*?#sK9^a*(CQMQobAx3|32x)M*kJ@My=sXVC|o#jMn)fo2xPnabS3nO)Lgbt zV61Cw5_Buvn1uA2wRFmkoOGRY9h5DSSBJ}+TVt#KY6`s2JS{SzxVV-8&sj}u0ADMm z>u&BMorF*?Yp2!6paCu<|9it_zS`=CtR4g)a7Sfnz?Z*g?&b~2$MeA zh})yoe~iDp`SkR|^Yh&`(}OSFD`L~jJJ)w(uzH*pcXY!tDjwxJ3u&kD(MdAfBnVeY zR$~%?IOrUAcvL2M6~(Zun%i<_U1j-htB9=aEhiny>530A?UgAb;Fa zAVnb6*5!Y zKB!B*5d)bkNhj(#BA+6rcG zFHwDHeN+{KxkVn8z(FZd3Ve!v*@QHo)m2WOot8xL&Rdbna6;&|VhtNfSHpz8cKCF` z6}Ahp4mX_EzR9KY9~s^xwLNrNx7)ocnn0{5Da^~}=&-K3TkGyMtMTj27x_CuK0zci z+5sWq5xr_pd)7g6u((P)XDkA~izOy9BRks4b#iIFH5H}qe$qJES33Tx82jtb@AezN z2WEQob^G}v+P_O*=laT0aXE<^lwZl{GF+76-N(!GzDl?+R$GKbGASq{LA!H|v{L1* z5v`>&MrtMnnH!2m{&b`c_Jxm>o<>wFi`of|(VBC81&t=~a2W_HYoXoN>Xvv^ld|<} zG>K(sWeAu+7jf{25=^^v5Roh>OAl;|6RTq(yl-H<7H2iNFO5v-*3NF}FmrFj{1Z$s zyQP-?FMqz5UwQO3yItpwuY)Aumy-6jnb^>3lw~C*81&A{-1~MZWk-?9J8yH8G>`_b zo#`Hpqhm)ed+IdVsqNIeP>Dd;n3;Y=Q!O3dXR^ zQCg2ycUIUcM?5sP!~zpcwd|Zx+8%gTr?M8@t5a~tp;(3OW~ExZvvCW1GQMq_Gj)Y% zw+eO3WOsDRzxwO*=lj#62Vb_YxAR|L9NFnRd0O$wzDr+YNi&@umip=-K=<@At8DKr zEiK7F(onG51XH!O0X%z}%~=Rqx5bYUXJsrK7Clr;86!8iD%YtB<;|9;fa%UtS9Y_~ zIQy-B%Odz2f%HH4qW$an;j(A#Cgao`TpE+sW%7A7}-=pU% z71De&dF_WD^+4EhP{p#TPjk+?z@AYe_Ob!zhETEdD{ncF->$ulIKXY;BByGjP|Q6T z6!p}Z!(5P*_Eb7P)^>bSy_c3^17LzCc;?x4usLXpDXtl-N*55nIgD-G^}jvlgqCK? z`Apa%>|e!t_mbuI*zGs(Kfn9yH5a_&rh4#|yFG3Dx*|%r)E8crsA`25-tNd>zOH=x%|t zNY<<2!eqSNcVHZ*oqw`6>pPtisW)4d&h|Lm7?&x28lm5?bdc%Ie6?B2(goi#^f=a3 z>DL$PR3v`8S1>Rq2?(TJ5;cgxd?4-iFy@~=+KCTO>+?Bx$-$4ldSCDAzjIgrumAHu zxUcy?{*V9oZ#fnQ9?9yp?#QKi%+-3|wbf&t%uii5Wow&+KgJj)tSXIEaaMZdcK*917nw_spz>rS@cs+EpYC1^y4c};|Cy!rw{HqYC^yWb+@X! z0QDZHwv+al?slr!DB#<{LmF(2SHsQA#ET}!RJ}}1tS3=*w~6WSf_kLF9EmgH#2?R3>axd9e)?%M5?@Z*36^vg zW#?JZ!mp+Df>m*Agd)SKzEkv_YH72WcIUrzb4&kc{N?@gyLk8MjlF$Z=6`%X=dPye zu@~`M%~T6#2iT*I(W|g>xbPWcb>t(Ntc3$pFx_Y?=mA#&CnS4E&wvMNfOTtrh9^Kc zx^PBUV;IIFp4xn#4A)aX(_t6`y(rn!ZRMC4lJrr$Mwx6;`$g<-3TuB{mI)#|>d9u2 z_fBn(^7*8jNu>4@}-^abf(??&zo3vT|iG@fE5sFD_zSy)ef}A}skH}I7 z44abloail^Dde(r)Y1tpHVmIu8+)qJWoWA|^dAim@>tl`AoMQUh{mQ3&KW`sE(AYzQpZo*8MPQwhK7FHDqoZ>c{I*D8z|4wO4=`sXOen;cCI`Rn5Uwz6?jwHOvk}P z955}TR@BR!EzeZj9MqB74Q6E%Tp_44(<=#8&8q>#hi89!`~3aAsqcfY+_#*&ZI-r= z5TEW=4ei-Ba?eL%tYm=pnlCIfRIqYiZ7lxsOLpEhfwP|TD7?Ccz_yWQ6g_lUlzNH= z@$(f^r~xVNEPQaB_z%17xY=BBK$BEo&G)La+0f|TPdmc{YqnH2ZbZu(0_1w_(Q}NQ zu)r@bV?r`f)v!arh44T=u+=b-q>Jv*spId|549C(8>!}a^+Emh$N2G2_g!NTzHYa& z^RI`d7IkA7gvkVN4T(5aUS~_)t?Q|cDo>sqKbO{vr9QkD3d{)Zs-4niKOH{cYJf8~ zf1U+hz1reMBAGgnkJWbY=@PrXH#PirfuwA)F$*&Q&4N~Mb*4m|)9}I)y>hsbwf8!& zWzksK3gC~E5fvnf8D#P`QZhR=1iiYOcPML1x@>Y?OmC(h>Ew94OovU@l4 z(HHIZX4WqsPsdgK6<6qn;ok6S8Tgo0b=ikFM`3;CjB>BNd^SKV8eje7gK z{q3hW@BT_yW!>YhJo?(*#u|PyP%#o0y2(_)R+wDpeVI-c5k`7LOE|ghx*o;E1 zhOI3X7cA<%bS^`XFRbkJe#yj9>N=|!wS(D@byIScCSGPUt%P>|Mj=>_zHHz6fMS17 zMmQ$75w-A=QiDLh|SF(%=(Q_pA(pYEvr1M0R_VvFzwHOo$oEr1V_7 z2dqB6usfB8-?5f@23C>6>vz*c7_**SmHHW>;4#_vmchR@@W;GXWxT(4!uIH^_6>-G zH^MvGN!4XNTe`L=3H7g(zUvUpi^JKvBFm^5Yx8U@&r1|y(8mI#gl8U}5`+($6`heB znU>BpYG)AVH482bVYm6hy(U*=crRTiEY;8)OO8Z1eh)iBv79p4)+0z%?nd--pSAY%qIuhL-d z9aCGErjUwga4xx{839M6$3@yy$qHciR4cYC6~o)}wZUq09z_{j`)RwVhCngXD^#9O zA1USB#|4T7L<75BeUx2ekRxEqyXs~wthI|2kYzC9dUC42vz)PW4mq3SmyD$~ts2>O zx(%rO%g6Zi{=@U9XUc8Q_vV0)zJ51Bvad7Vk#@$e5y6a~MRfu^dB&QjX&H4&D+TE= z?v)v5oEXhok+Mdx&=+Y+@1ROm+j%kV$RXD1#Y@OKF<_w>@j5PZP;X~)5?Up_s>Td# zO?pj>axT(*dalgpOK(n+QYGc#`5bgqgV^#xBhEIxCM85zIc{mueCy~NAQCsp2)pPoVSJrj*ly%ONHFH>3Jn)L} zo33a%vYbKSeb-i2mD%9b=h9Bl9^13^OdKqV zX~Q7D`t4w$hTy9ZZ0vSbpiE7FX(|4zwIJ7431%Z9TX@hsqX&1DF z7&lxxkgMf+L4VLef}4!~WDrw#t%b_l+phK(Rp!DEVGCC+2Lv0bt6g}OE3^Mob7l?1p ziW=EA=pmV+b3nx(UZ&JoWR$E*vr5jg%iJXv$KGkK+UM$+u`4T$*vxNct9@JT_#C;j zU|(ep<_@}b&*iDT#yae8abF*O-M%F*+9xG^kkjWm(@SQExdL{C+%a&_U&JM2*Ut{)_M_Yt6XGy1<a-K zkvoVBXTThQumYRL^Fs zbs$+^`HE^3_y$o0Pn4|G#%eYL_J4h~Z2B9)Bt81FeJkC7*j|Gc?a4c@Ty?cFdlX&S zjx=L|XFCB4?uU3|**c=HIyuvE^c0(w#Y9>xzKp9Cq!tN99|#0h8y|O{y+P*Q^{T=@#nb z*~uKNqkWaUTdPa7o^#l0z@EQmJS0x4jjyZV|NPDSXBI{uzv5SZ?ay!Tvq2wy0dEry z>C35%Pc0KuTefkuqxv!B)t82rT5Re}78|j4*Q!|SG=LQJFA&m6fm2j+-^4J%g?`qfr2Ll_#zOG-DF7MX>byQ7UaYKn zNKSRlD`CQ(aIs~cyMb0K+vx3Rlv=dy+~iPjI5ncZs#l;A-l_Jp^I36XT!+IY^}WWD zlfW5ot8rZ?I~Jql%dYH6#?>s{upMG_`Cm{bhdx&_d5?*P4UC&LJg! zYN`d(Gkphbdr-$6T^W|R%xRa{uI$rsd#8RieBIC1yqS!!^WY8Q)PvUEL3*Ka+?Y{2 zWI1J;<#sz}@=}JRO^xLGHPh5Pi6x}8GZ~*FU9w&GB@p6r6iCMKGq0~_vyh0iruKHi z>aqemStH5O>%1UqUv&f)K`+7IKnP7&@VmF4*I)bd^B>>byPuD~Zm)?tFGp_+Y^F`{ zCIpHPuEWKWzbASD*SkU1sy!5`1eE!Xe8Kvv?D$7mjxOXZb~`x_9kaoZt6)*}>QH?Qp>*9lJm&R)&{edahqNr=_ih*bLY8#Nx6kO`pZ(_E z_w>O3BBga3N0L!fm*W{{c>;#ubz#>mmYS2? zM0(w#(wM2xZ*=xWG#Z9_J7$AuQ4HKz#;z_To!zW-%8Wh{qOUk7Q>||mY=Xl}I(^iA z>^6`8{*6EX_zjHNqc7d<+V|^Aw^MN5bpb(zOR&~iTA-okbE1}&S4kJYFU5+wyd#5U zNs?u>y;JNVzLIDBY0+(C8P!oKjx;M*IofO@II z(zcY6jSg6K$jp*#rrsmcDCJD1Z#|~g2@0;9DEqPwU@MTFuF=mb%c?|~Yx~h1tM(P< zdM0P$uL#`d;0DTTNLXApcX?h*j+0zy;Dm&$5dFD)6-p7an{J12NUL)5wsqxZI zO(sXQ)JZjGmwvjOXlQXz0(cEe}g#wtkatDPh7T-AXUD$xkf8e~6Fk^P9K( z>-*W>{N?HWd%y3(e()vy+4C#kW&QHW<+Qi8rJhOKfIS>7M&9M3@SDmNSPVUUT2M92 z3Nw6q@H;If`DT*P5AV|`kVEF!IjI!P9NZ6+68)T=cOJF(+;fIP1L8n#GcP?+^3*lF zYVIq=oB}pC3HI~RydWy1gfenA)|6|WoI)E0Rh^KbcTIn@V-3xkXR~< z5wcHYtZgUU#L*&0%|BJ(Zg1^B+q?bY`OW^O5&6-V@msg|lo5y4K$evE7_+jio*gqa&DIY|SWc=C^8w~%<$C6B zLU`$w)4tVhR#R75>(rXXOtN1hJM&W3@gd^~9Bc!{O0*IYr$a>)RSKBY=PJ4Y+^4mW2?=^llQmt9y&G z2<6OqB=)vL_F<6qQSjj`t_@r)NPJ9eucN)4XR=EM z&EqktFA%`mku8d?Xwd2GxnvxFqGT|!rF+ox|UX}`Fs+=nv1H}RA zUTFs_-HKN4Xk&E9aaw5ssv$ZA@iOUXV}_p6x+aa zX1YTP)DL#|uYcX$_n+L)Uc(Px%cNNKwmPBE!VX)lZNI(ENe_w2el&M)=CiE=0q`-QAqY zqu0CcF>LP}upCyOwy0V#*2uqH80+4%U4|ZxBP?&DZO5J1WR!-C*wA7FiX0-$7B0U< z&^umfMT~j>r}OUo?G9mxpgOsAj@!ydWsE;DG*W2~jf3$-%s1O=EfrA?C7)n;nZZf^XGk7`3!{AN4U= z)UmR)H=qHh2w{t{)Ozy)0PfWfe&9S>eEJz{)7cyoeU~ua8(B^EI#+1tg%f7Wqt;|T zjffbx8^080+wFGlmVHaH+0|h6rVTA-K0iE9ecReEyUBY)&7Zu6AAfKWuP_g8v=^t9 z+T`+t+<=S8xW#w|l8g#`LnNP1-Tjw=0xv5i; zc=TuIQkgT?H$%;O5-e$JW3?$XMb?Q^D6MK81GZx^4lTX!C65$w+%Ye1xjHC7$*`d) zahC05zZ>e+Q0O5!mooj|-7R7K?oqAf|MABk{{Dkc?&mJ!hmS5b z_(oZ$@3GYR`J8r!Vj4YojHBG#bw-rIn0KF7#AOd7amaCSwuW5(f)BIURyz&uj9Zxw zXOMS9kvwwNG6t;hXc3GaM_#W&i^<_q z5WJk$`t$?=nqz6LHyYvkTQC%5T-&$YKxsR=?$Nr;_TbeCCQIx4gYEsd-?sPrFF$?N z9`D7N8*_-F4p zL!eb6pS$ts&@;f>J5$ckI}YQ-u$X+H#k}%Rd~T;VOd?`C5t}Q||7R_~vqYOiKlY@-srLrlBz41+33UT)teO}Udz|-Ze1%JG=IU(X0>VDCzndWHI-g_ z2d>pe7xf4Ekf1NoOK+V-@f!o-Qn<$!$5&OI?A#-v(k=uKv0GQdEV=qxivgSYjBnVV ze>ea9<*WbKcenSmm+_)b9CxJTjmN+|qI_n!YbcYwZ8wn96yBMkfa zrT0^a>$1yC%C1WAPl-7+Big-1@gz=hIBQH&oyA?p3mOI=z!dvl+m=0Ya=S6+WNXVQ zP)Gj!v-`EJ@}6b+vlsEB&Fv0Pe1dJzIt!VxS%F1m#72W_qhWF%<;3+nr=2q)=cA%g zJLkr3N;h)HsmJ;{vvS=oyK+yM%Bb+eZ*~Sr{V>5lp~aS(_WEL;m;KrJuw4>8Rh@vm z`%_S-+j1Ip`j|ayw{tibF?|X|T+~mFde`N!QcJ^NHhS&e6lp3wLf(gTBD#%D!0y{! zX6W)+%N>9II`n=SWYuT!Po zKB)azE}vO6_8oDvVTu8q&*&@QvE~Z~e;GyES-lJGFo+zZz2UA|l?~4DX6}8W_OQMn z9@f~c)6Hzv3niL5cPq)gp-My1SkW4hSBbe=L_b$CFyX=RPO0?-y+kxZN zAs0x9h9j|$Q~)1W8EIP#oa@bXN-$r8javXcft@LxiuB|3BZz!d_=XAN+Zh)lb%yX88+Y-iTo3 zVT26T!gP$U-qsm2pyLg7>+>n(l!4cPgJpofuQtz-oT9|cNpi3KaAZl-_*P*EGV8`( zRhsP%?~Eo)IUgOUe*7tZ_;Zi$XD{PN+q>57X*woq}n|CKF`a&#FuCohxTINx^q3&#LgQL4(Z&dycq?`wI>CJ z($FK*0_1`>d+#-Z`*4l`gN{cAoIuS zeTnX>sq;c$y>MHrX{{68R#}zxLs^rzW$Zfc=s7iQ_fGY7mX=tL^@4uv$StG2ZZ3T- zWCi;o;A;gmi&2_K30hj|Yfo;BG(Dp@tlrfLGBC(!ZC~)-#_wZE3~s_>jtl7<3&508 z$e@z~o~`stU$HZ4owm?)ew4@ftFM3f;m5BZZ0%<+;fFQI-bZVD_oXg#4Fa|)r-Nj# z@s!@nc%VJ!UV6ynUwkrtei(PC@RJD!`He)?!S@8U9TeK4ac}N}IiuUKEI{w(Qpc3;81W9p6L;T?^01(NhU34K5-+TCILh zZKjD$2fl2H#?8M#$jqoc;gMT=kff`8bkF^pKYsb4$;V-gPhP~2HkUJ`9P6h+-DY0D zB@|!G5wp7MARTzsH%f&|5_HK@iM%~j^z2zS*@k-?z~?z@#hs{^u1AZxt_4qDS$3jL zSJ_MxtZKfiyhd%{2rnkCI`!E*XI!+HM1ps6^we3Isc3n?!0rJZim5N0CW2{mcjF!i zhNggOIx5n$VM{{&P-TGCR4b@Z2wYz8;|@#FIX|jE{`I%b{h)d9*=zXWI~ia%P{X=0 z(bwk0=+`Apn28*>b&Rg&;w5A?5#*4WYeWlHY! zM=cgWkMj;Zv3r+&tnQ)#%zbRQq~lb*T3-J{rJZp-kp^HcePXHSze9NN<4o3DNrevG)A$!#A4r^r=BCoO{acRw6c7^%#^Zsq0O^?WO1=#pXjHM6 zaG`U$=xY?r>ay}KR65n7JYs9495zo&^wxXdVx+eBW`ICS?prH!GhhX70%q!3t{KAD zQ}odopl5W+l|HN^{xn zI}+{^2lg0_wlnl#&d?wk-R2#(n>8k>ysm*S+{Pip8NPO&bC2!Tt(1aYgu44uU&MvC zygsA7DrlgZ!=>~Gs(xlp&OI}v&NXN(8$}6_$#T=@MDLksB9X(G=^bMN&FTVdT_shEq_0L|n5BF1HSwBV|tLsw4JhM{j zS`}*d=|Ni1ZofN=w>^v8&ARz8ONR7&oH2kE3qC#-9}Og{63`ro z2JM1G@HID6;}NCqRhEj(rK@uk+R3YNY&#rja>^>A#_h$XpRE&QeDym0G4qn+rJX*d zZMio$X$xiIs(IFRaVdkop1iGd)n;Ra%6-Ls{pCOI-~ay0*LVFZpS*A%!NxBvWHMzo ziDXxzf(;GcS$7>QT@}{o+VJ$d?^CsESKTTK{~7P}9$l5G2bQjt$*Z0>i}YdIeK1~Z zy|r(c-pTMccoDJwW|n$Y3S=s$TwQ0MWR~Kf7wl=XtaZ%qdT^N&vV6HsncS*2j3Cn5 zjLZzXU3#%jv35sami=m?*@h=I=z^^$Ay`HyU@@4HoBOS!`M>-={_x(J=(CsYBP>*# zcEJ6vI>gs${3&;l$OF1 zp(_K8pKCeyg(Zyt zRyLQ?YR>jeumX(3LuFxjkL0QJRnFXW=Q^yOUYbYgiioIO1XLekq5dlV!Q-c2zWn%} z`RcRR@GUz?e!ai!W_R6_cWBSidRgll1O*5XMwKJsaaQM}FmIueFl^WyReFflel|0Q z4`X;FY{+_?8VD!MUA&x#SOC9Qv?V#iz|=N6%WqCcU78Kf1;nz)bze}_Wl%k<-X5WR znY_5lW?p(u@1YpZsIAsr$5!J0Dtp;}Zh1AfVa+JI_3#(lt1EMFd+%@K(x;AYy|4ZH z?)^{k^Upv2{N2}Iw*Qy!e%e2Oji0}JmskDS%lH;0^y{N5*n&%Mj4JE8w`!NR?=#xe z21uqA*njSX03$U799Lqy(FQrNcq6zoTf|-{t8%Yi$jC=r-jpS%f?mZSgO3FCdtTc` zWxaOkx(M873UDR!5P7I?a^Nf95dngzW895FYr#>n)&{JDlBkD0-gqTlnsqi0&A5atNK2#VXmd&=N}_>3HS84}&z)P5a!yHFEM#=v&^X>j+@# zbUWEfF=B&wQP0>iIJs6BQnX<&nIQVAw&#}107orKo2vGDXQcC|m|hp{%WNJt^j>Kq z&VcT67-69zvCIbPVrEKSU9jiJ`;WhVTHiYofAZpeWN+?}YaX9tvjb6ft+k#@JK~$x zgSQ4)xY(7xM+Pj{RdSsXv+crk6lzvEi_;!KEXRg|-hC#NI*FAy5RgTQGp3P2H>JOm z6)*izCm4q)W}VvbKWvoOD|;KKP0$Zez4XfPGGq7LH@0NDu*qp{p5GG~LVmg)}#lB9Kn?s!%DZqZM zxgOy#(irle4@IpApGjHAUMmwq#BQK!9(B>zwuC^geYM?#QI}Fcd@1x$j<-YVn%QSr zodKCx)@e?*+B?li<(xDIfuh;xYWH?PS(0*Y4#JL?)*G{mC+mJCrT(iM=MV3BT0VQ( zUJFgXc^{6?=DPs2n*s6!%fe9^s1TkA(4AO92KJFvS{9Z}m>lBYpGE5MefUIFJVs>? zU@&u$y3RVpTCXvO<_UbvbJfM+bQfpv`?Z;xvl~q^YTWB=^pkGiqFJy<3s-Z7<;cor zR&~Ni5$%?`Z@`%uO0ViP(5gPKHQ_KdU}~9mQmA?8dp+3qP0=&GvGC_zkZdUlU#_6C33Ju*w(jUmCC zB4KsJf}7*kxWE;@FeR>l1`%Z z%F;(fKWdRukG`IM|7HBL-+SwR_Nu+^rv27_qd9EbB(}p=IZ1AIjMFyVo^@{R$X~eA z(`bkdTCCq3*$~_|E6JrB6=1V^#%!(}Q_N0dib68?!_G^Yp|zAi2IReZ-Z|d1->i&? zQR`Zz4N@QL?7J>NJI=Q74|}r`ddJ+dYqOTJwA9hEwHSMBEZDf}DR4HDw;WD4sjJM=IPL=}-s1fTTp9|sT zw0)+-@;p+`>m?@2)#;^+Dl%9a7$kreT~BH)2WQJjW{(C^8iFnxt*z2R9C*F>nhT+Mo!ltL zq`(z@&si8Mk2n72R)<}U;N64(jD8!#=WQ47C2}v0B6=kbSB6zbqqohAR;MjXa{Z@B zUHxIU9Wc%tX-7MaAIVnPz0Xch)B7M!tZRFnbwOo${f_?bmtTJR?rGM%R~r26#rtqm z-TfrvTCo}8S4;Rv($}gr7#tW=m@VL=(^gGyqtWp_WgTYTix%RTFrT;WwRTM22}BSg z%G3xkDGv~W`gxx_Yl+#2cldd&^`1KE5sSuHkf^)Mk#K<)A`W~B%(UM=tv6FE>8)-4 zHPn%w9RA)Iclyy?Tc0zhUp(zR_pP_P%A^j!`zr`4trVv$H><{d^~3&$@8jpckMI85 zZoa#qaZyE zE|x}9)7=a5Plx&(fOK}H8J_!cd}$kMuUc*Kn)$T}cB%>aIRbT56^P>-3f&8u)NeAG zbh27kAwt>8D&|I%w zMqRYCN4sS#zoS)mdY{F*F@%YcZEO-=MSH8zu=Tz4j$KQX^Lvl1!^Q z`~mU)nmhZOAAk5Rzx?p!>+j;eS9AE}#e02F`)^8TWnOfYedcIP2%bi#c1#;fbsItx zEEB}{sKQEZhB(g`IimFl*AByWw4;e0cpKfP%OT2mq$4k>jpkD@okmeC6y;3u40(k% zCEPLWp2i1fs`)~Cz4ttGk1~PzEN0?18u3 z34y;Ik5ME}!!1d8)Mk*PjkWrGz03UggTGf0{Oncx$Q&AJ{c>hDC+b0^nGv(S$x>xm z&7TG}Y$Pqydchu(oWbOtWn{;Rr3Pw=sEcgZCWMo~H~OBwU?QYCwHu9!!}->6~#_0wm2zku}FEBCsizloF5i4EjgfW77_H^&HU zQ>D31s@ff|O*g7vwtX@DGxu{z+}@tVW|3RO!4#q&;w*Yy{8j_}7!2cK#Yp0E6;o?_ z#xflM#Opw#B5cbIfhyqLodIimj0b&E7b+;kEff3}110CoZTL&-5CGysqDbX5agOw; z`_b4pFmss8JHaK6lA%kVVf13tJM>yF%%i-1NPqhI$A9?8@Akd#3fDh*?cN@a=C7BT zi)gePBafqag9z69yykl$kkNA023Ejelw}rFHh?0Z)W5GDj0ECXJ+}bfcz#K)*`(0d zD%>S5=Yc~cv$s_R5_BnYU0-4U(Q{i~JqlvfbYsh$3okXC-EF?dn0ArOp9E~`WA}M_ zWYHEibJNC>wc|{`K^|x29NWJX5jp(zUSq532LW(ig9$RZO@^w#B7owZRY(6U$oKta{w^EkZqYCDg z_Em3MC{_X@t2pgj&Tw8X9TDwvN&byHwo)79i+kT&U^Il6YDdJx?k8H*Y?qt6~n?HB1WD%(fs@&UIyAS?SSM z~W~&`i4>QnnGe2uk}f6hu-ouKszoe z*A_U4zHpPR*=wE)CZWtQS}sy*WM6&Pi2^(7ZPuLXp>R7CmDKA=e^Mtmbh@L1EOhqy z3|;K1uLq-l`89rc@6z(wtM>YI{#M+r#Md5x=d8Rru4IWLQi$h(;wzf^jICp1VoLcu z8Kwf7U4Nzg%Km)8&I(Dj__V&=KQ z!7*7J?&1(SO0>NkI87s=uq$Mip4z@eAKa?e&3A^IODXZ~8e8`1LvppXD^Qc16>E2E z6)qagSFK2>roRqY{O#BH`M(CK?O(pUr!V{L)%)lfh1uw%a%1gxL<2Tms|>*h0&L)$ z&hm~nA>q@rF9e&OfAr=XFdCQY*eJ%V@~*oZPSoXk&&gv>GffIPfFftTI!M;_&RPDo z#%pOYM?0~g`4x4Z$w9GYVm78HQN>&`%e`*H%gR>jn%q$+3Ka#$;~M;-jpis_jzQX2 zm#?yK24EaJbCtgPIOk};JwOn?mIMDa`}v2j?^cXHd*$99bboEFUEDSDo}jU3P%Td8tU-j<&6C|C<0 zFj!nlVKV$Ih_^k4qh{qsM*M|}R|ReSpx{We4a zq!xekSeOQssj*sDIXh3DKtG9Bi0R%l$GKc5!gUYu**dVGVeicG&9)kheVmcKnK7FW zES_Rcx%)s>_H6Z`T;0JSM6TBy1G0pb6ZHi|dzfz8;V+yvW{l{4T?lB)+LhAky36%k zZv`jn-5#s2a?4XwVwkb4c@rP2BIck@iWevwVx1`C_UnW2OHdp5(`fjA{)-=e`rd#4 z<+oPp{`>ghz3J1>UcCkZ5d9+TwE#22(_S8<^vgvG))3T}@gsO|5 zlHx$*TQnbt5jXdxz%CxvSl{Gkt#V_dX(;q zrb`=2+RxJn>|~h2-#^6t+-N+ems-}?`}Q;Atc0uTGMmzyURCEpK#`=%yfYxmr@D+S zMb3P^kp87_-~PMzin^b@a4$14>rZc8+i`h2o$IxY$W{|w2&4A>ZkyHSokF^Qm}VJX zwjy`h0oA5!avZMdY)BJum^}Da}{r=&XFaF*)^|M#;?RfF8-_!*(sB|KBXSzj~ zP>#(_X>IgfO)hN5?u8Gyqoj3-ghpt{Z`r%^S%!mm9>-*vQaxw6OQHr0%~yXPLc#>8JefqD0_!OjrC&q}#8 zPb&*k^CA4WI{;=N7k7Blvha1Il6q@+_stb~Vr+>~r{J_)J4RBikva1Y^FR%~29sAXv9~ZEvdci1s^v1( zb#yvvndho8$tAZkIjod73Zr>;DSGD;MxsUb+WoOyxX&CvEKd!Cng_ z3(tl!J6sUOWs|t|5G-uL)EY6qy!B|6UU7fTU9$Bv%x~;CuOs9C;ZOVe)0dy(_g{W^ z?@RmHOZc|x`IPVyarHv zmjxLv0LBb4Gar*+CQsd6OHk16y=RYY?IAqr>w);65&i13SMI|(@khx8;(z!aIn_Gw znM*rk_SN}psmeJe5sG44A}qbz*lFZrulF(nX%rJfT8@-4&ndu;BJROHqDzmTZhIhN zWyHJQ-OO9O#z6P%Yh0NEU;UELYK?J!CaBkjeljfmOfj1<6Ckv-k=GX>&8~B_q-t1K zH8F1fv)2u&2c&*Te`sY*3OK19_QYwu4jypl7}y?-i zifVNQka-Xp!{|^|wbuHL5(@~Ld+%P3&srg0t!@4sx#XN@pdn_7K7f!~S@qFM+)ZeL z%>0`c&DWp5yq9tK26ishh|&1fb#SHTK1d_H7bZ03XuOLlEP{xrzMnDG*Zk+#o$=lI zL*~1U@y}ko-!}EH*wpc-oI~j~gbVU47Q~u+oi}^3hE?IXY4P@$Kc>K=jnc+oWRT&l zmHe#c>fna62iN0UO{OydbP=W!LI<0$BINefat!TbE-1@$yzXf~!l-8Rk#1#(5*pxX zlGPeyinJPViE-Piuh$q#aQE&NexOg!#cZ%1IeW~EoTPlrWV53uXX=`-Ifs88@m+rT`CT;VXRq8pdEM4O)p~PqRLn->S$Ala z0yC^f6~=5r`qpKAA5*3(Ma^cR{N-_n$Lxy$JkLan_K4{=eTl$@dOCj>_91;Ir|uS( zX{(lk=j!(Prjn1quuyWr{Y|^f^aOz`i!!BQ4(1%GA;6W_dg9J;tlh}gRwDS~fgN{@ z?W4vS=F8o3H= zrnUvEi=dgj7Gy+F{1z0Hd~{yVw{0!O@muF@B~KC6X<0(-)SBJ$wi)aCCB|Fb7!|8) zoyGy@$Y99ZYTxVOXwME|NTl|I;gH5Rc5tyY0!=r&7}$$BM7%)zeUm}@a^pMy-TvW+ zcO}T5y?P%d%e2pS_lY))WW{3x+%5UxFg^dwk@5C0dH5zoZB%#NC=Bzei&{c>zpGx~ z?aXRE9=~M0=a8l8GihJT-~huxAFXXxT`;#^o2Ppr8|iBwxCgRsX?@Uy3cj5-tTMCT zw}%MA!s!(+R>=uadwL^g(CiM#2=$Qr(x@lB(?oq5%4L8%t9Q-ZWo@bG-^zoGtnsp| zf0aM}{Kx(CeRsm?vzP9lymHH*Qe~BqMw@o}IH|VE;rEYw+jN^UY~Q^a--wu)l-E5v zlY)ira|_VaHMyOq|8FS!&kI_OF`1Bp-Y z@Z*|_ME0UB^_1fX4d=X~>T!y-UdFvxj#{d(5g7tB0s`h}H;uW;lG{q%SU%64q1H?L z=j^EXj89tIY-$<1M$&MrfoJHx_e)5E`RfV+%NkX0DrGm^x2E|(c!3- zc>wHBqWjH2Sx9NSta==@=9uNy=Y>(GOi3Lpq{g&bpQ!*%UiFM*N1Zh7%@R4O=Zuxw z?J~%XHQG22tbOi7Wx`1Z0Qq%Rc#T;r)wxxfa;QerSfb-Ho(YJ7tcd&w!>5k@L|%yj(|r{`oryW$#@_ zKY8We_FTTTNBhhwQHY<;1LdJrvHI|zL|fyGU1E&oM)-Z@)$5`I-bFvUmJMoZH=2&M z8Z0dW6kvt6Yh70HG)OW&P-WMrRJ})+ag1@UH`ArPG7NDD*TX7;8Y8pSg!>NE?UE$n z9Ak$7_ar|zdJN-P?v+7Oy3f^)oQ@xDbm`pM(K1G2WaNB&w(^*-b$~y>%x#46U#Cm| z)kiI~&tA5FS}-bqSARR~UaTyur%rm2>6d?1Co0*-uYKTEnGBjqqOC93AB>epP0+vI zS7cq__z5MRDkQi1xKQG%Gy#(^uhw`#a&1Rcy*QnWLB7}4=s%M&r_Wxsw{etT<$A4x zoA%M>lohis&F5R*A1lu+hyc@aKd6xCbq=sn$=jGi8|Z@Sp#uFW>+DuRHob zfBoJ5`KRyh{`rqze)!O5``PRGBF1d(*Cg4r!9i2|rYWn!{t@ROXxF z{UCu-ce|rAQtgLyMDFNHSHnix zt{cc^*_wC^@41y><9*jc%SEvCytBLi$G6@6{g?A!zx?#|fAkc8_IkclBYx|OYu;d3 zo@`=)FkKT+3nSP}I(To-@XwN4dN^B>7YCRHH=M3Ujhro3Cj@dYoj4 zR`?(ZAk-3;Yetp%}A=EwtE-!DO4!)32rWhB)A6j(Ui(p9Umw?!mpn5mf-j zZln3qif#5HZYxj<&lMkS*IB(T0x(UR7_h&hHV&R2KQ+%B^3FE@Z|`pN`w#PHujU7v zEPc0Yr!KG{vKA6$Dj^01k#Qv&@NkG^M)X}{w=KF3gbIr+aLNyw?2Bs47bk|hwC`S% z)+3f_yEW(Ca=K@AB!uPW+pJSFs}1q!(bX{q)WEhd!1UDoVlk9RitfB&bO{QECI z{NW!ye3UMZt)t$l$PY`u=`C$)0!46FV{E;+FQ$DH*U^^ZeR-Q# za&7Th8Xh&sMN9hd(xdMvOY|Vs@jXt=sk!r>N)R+&-`EszMuhjncy<%9PLyHBseH1$ z_-%5l-3M$vpJ(FkJboSc*RvWBcy7D8pahCFY1tk;1kn)zAYl&*+aJrz41^)ivpQwjz>dZ7x7xFsL?`hqmRAg#Ar-#AT7lg zhAxxo;*$S=pX9G?m4A5eX#L5{`N5OSdn(JEXU^QH^s?$%V&_~B)kPPk>CV}fp0fk0 zaEI}TKm@L9WHMNA#+o-yA6XD`peeK?KnEMfhTKDXJ(VKjVRrQd6Gm@lAQfEP-m;e5 z(|p?TrB_trABQNI`YV7>>QGzwTGQy>(tu-#fH|^I~A`Xm-2u{ z8EO{CAV@axXq@B!)SUevKFRNYlRtYgKiFdi+a=FhRaCYjlWsYIS_hr(!OJaZGzGQw z)-vD&`f`)!gcNHhFU|eUK7w0;udvP10R0Ve9ssK{F&$R-*S9r=|2+|U z&kn}3G6w8oH#`?ZIoWx$HJ~JLbx|`a0tE zdM7m)O*77cpC>90N<`n;!;6J$j=s{bA+Zn}u~)T(SeL4LXA+F%GNF@} z*orZF_Tuqcji!oFGpASb)B+yQ)D)a@eOPG#WXsNSXLc>cRLi)8*G8qi)OOTp7YV_x zYZ)Pi6sUBTrJm*%82E%?J*_9GP+Yd97Mr!d_ig?UzwPs%J6(VFGJaGL5ubjksEnwq zS!oEt%UqB@O~PV>W8BYqaD+9kCcaGdoSGtp>ntD2<_SAXnKky^@7TMPN))N>O3e0d z&YIV{R)lb))e!UXdQ(2eEW<(Jhymps%tfd3`06DbyjIrz7%Pu18yLCvM1YeVo|h^J zof!a_>+-uqbX`Vh;&4J4Wz{0Fng!TxhB6!eCq}<+d+#y+cQ4!f-qq=o7xAOb4Tx^_ zRuDoaQWosg8hVocq?TRI)BrAb7n+BMogsFu3+AVooeDcPiqd9144SGYqyOzbuxd;L z?uS_P=t--fQ1oixSNMwaRU#ZQ9;O(XsD)Yviq6AC+>KvfQs29bEwq z(r{$Z<*wgYvpUPYPlT8Gf&vPrW#Rf{$46I`QIE58&Z48ecX#?H&+bR(>CaxqkG8iS z_1;Px;9ev188J`}G`c9)pIw?_F{4LdKo6pDg`363-Gz~%KF**+n;}WEiNwMkMN00u z`r`gs$207U>2LI~lYJl(@bj9Yg5BEk_FcR9fI6zfiVwgVYk3Pq46Gn)J9{nsQSSK)ev(>fADud8&6z0bunG=W|55zIgN7e0J;-~a4>_9A|? zxzOP)yzY5~V_Yr+|nJl6$ZY^ouGWH&|Hd!TKZ%b~sp4GRld3T>h(l$5_m?E)Sog}+Kad2GL(bn45 zdmV5|oOm)kJB{9bR4}#;-z5o(kWTELmP6Mz#$+%Ed+{!{IirlAqwYJK`=9>1&Hb|{ z=+9otkGA+2IbhQTQ2g+58jGJ70l(5zW7l=OflJLqB-P0x!4$p5_)#UQ*jh?uxGIWY*KV}>DF_|J8*}Vs7Q2qQ zTT7qbg~CR$0ePugYM5P^%W?}4=0qa{6(>1n z0`@;c^fFbu8PAyWsZT-iX!oghsX-7e)}QDLP`A@+?E)RG@$#pnux+R{6L+HI``rrl z-+tTRKkl#JH+k>V`^hW#(aw&>zwF5Eb=ZTni!(13A=$o4TW42OJJeIx#S<~CUgndm zL!Gbfh~&-#vAZNH#sET?L8ke|vKxUaHDGdjr+_Fx)Ui#Cm>lhI0TU^0Cqh5c?96zUu#0p=zhy!OV2 zG$#Lh?Opy%m-vrgerWRDm;LVUe)cN&n zW|z*u72VgNvD@9VY+XS33}Z!O7Zn z-Q$Nb)w;@Z%)Yl~6=wXp>WWg|#OwV3qwejN?M#j{z3_y{F)4|n6l3emG2uDhjLNL6 ztSTSrN*s}Y)eRC2z}RS!R806LY~Qcr{QxxCYwfK$T*84EIzR(^*Y{VI`R4PyfBPbM z*%(EYsger_KS4zDAmL%_3Zz`d__ z_6lVlL;I4FF)SCv@Qf{|t* ze}mR@8*0w_RPhN#$d{Em`A?gG%4ZjsQ|SUTzIF@B_l|7#$JOyNNHavl%0C zu8}VLDyYwxN6(6C00WES*np11M9%JbFVudLN;o_ah}OBsfPsU@sq~e6Vq(k+fkV;4 zuPc?vywE`G4)~IFr_A}~bN%qIFNV|~y>7RY2l~@P3Q?-l*wF0hIqXn!V^Rufr?F9P z-9my1^bEmd@vubTFn1rZbOI_jAd$FwS&C7r11=zl0xbrL!dkR05y4JAi@P?ALqLOZ z`_4rODIBBB@X>F{EeTDVj)SC2Ebw0!c(vR5$!krK0+$)J@r&~yM3D5bNWYZ4C}RXc z+iMWK9+uIY@yf1{LTsd@a%zd)$yNR)>%&VC*hjD0YaYSHbd|6mrs=zjoLOr$2rwL) z(kQJ}FcP)h6BQxH=F|=yDEtO|?Vg!H?jtRHC3CTfFJJ9+d<$6IC|De47W|uD!q!uli1C;;^HJVXm2l&qTpX1ow(6l z%t6~BAfqnfunj@HxS%_N^%m05wvPLuNO$?6zd>XhDI_7L91*E7r39hX!Cqx)kHiR}(@D}NKdz`6x`7wGZPDzdt3FMJB zVyQ}M^!Ys(D3mmb-a-X1qt>wRYl$-&Dlj^4-@G^u_$c7=!ZC5zp}1O|f%9N(QGnsE z28JGX^om%9vMk>`J@@blav9Hl(Ga|M?*OF5?$O#d#D{^junjX`C^cgs`kf}X*mwSh zdKd5W&AXS>=#O5xyLpn|(HEo)vX!;er5%TOvF8zIbRgyh&R9)X_A&SnoN(Gf`c~R) z4ZT7reN0Ts4In=E(R1K{ouS=FqixvX1R5b{Hq$tV#1ddq!9 zvs;H>U2H?Lgz=-%qrwEGx^~nQ#1}aofagIB?;$EPRc(6>?}LFrJbf_~k4I-)JAf95 z>^NX6=r6Y|I_faZk%=iGQF=1LYQk%7L5fU5O;7h7Ij5q{Xdj-<7Gy1zVX5YS`Lc!YsgA z{R01o+^1p2lbGOUFYnzZvi$8FzAS%vxNyb;of{RIlitfT6o}mwMlcMBS%9h*2sNN5 zl?MV#!ST^!V7_kaHMIowIr4@3nB4A#O9b!8y|6)0mldeA#dIIhky-e_W1UxDZuI+_tN-Cb`YI^#`b~Cf3o$a=y^sBcYe|&mP z*YW73yP>wVpRQ?}G5Zo6w1{aY4j7zmZhR|fl_Evk8tpug5X=dxii07@T+;C|_Z|Zq zw^99^>Z5h1=GePVs0$d3Ed+BAygG2C;Lx!dBVBhx)ef4&jF_ue6T=s=4z*l!OBWp^ z27y8m_PN%liiJ(n8f{N(I?0yxwK4cO1qNo|3Kx3L)!|7#<^IY}wc^cQ; zw-u#-e10E)_#Zv4k6yz2BhHuNk`q2tm=>z3K#74t<=l-iz8#ZC48Jx4X$RsrWWY!P zakWkQ4>;keUOr1KM3H!S-|U%-v2lr&v8?i0B;w0o3iB>=!heuVGdp zE;b0HWY}_&$b<1_hTwSEn&GCiM|BFCVK{+O*5}VKeviy!fl%4Sv>B!6I z)eB9Z;*5en?2{?C{L^3fpFh1Q9DMY$-GYR^8qHS5IDLyYBbg?2y6A<#q z$q`N43B$Kc{PN83y2#iWu#t{+5anD&TSltsu+mhFoI`JNOj`=bIKkPXWkO(&@*P0; zz`ZgA2JoMB>_NX-iR7af?zNgeY8kn5?-47k=Q-X)yQYocZYT_Z!mx-slBL!d(NS$hNlE7GwI zK0A?S8~B@k@;ChNzpNkL*@v&%!TX?m_(IvW{R* zX#p$Jx6>`I#B%pZT!{n-D=1Fe@ouauPS|sXCemc-R}l#;mfcHpc8uh#D1(v=<={|%&+SCsXl&u|M5lN>w}l>_LBCm+VpG0 z&|{$x?TZXCMa*-pdElbKyRH#m!}kuuRBvXj!xc4*W0z(1;f+q1jJ;<+vvmRzTA`pC z>{BU*?YU#E>%?_N!wloz>kcV?01nkm4Lj1uN&(4M+E$^_>}(RB7}MCKI$5;s>C)J| zcp$}4z8mas(R81Qwg97!yrH3++j4I0I1sT+JkH(GjHeY))Ro;jIezore~-k&n|IG2 zDqh<5K6?Fb$>P+%d{na^Pq8f^8}1_p#|H`EE|dH0c4X;j8)?jINI&4xGJ**cDa)bD zWvWkI(_|qhm5hCA8woM-bm;@1E*u=9ui}n(YR`3+3Eh^I@WEIec@LKX&H!QGA*oV? zeQm2VafHBF12S8ey$-Pg48R^FGC}nnjb_wop$q?{sG?zhvLKU0XmQf?2>i(k#251L z#?uj-Y1p8*yvE}%;0**mk5)fiI&uWE`! z307|-liay_w=)B)540q&65A`#7d`EuwlbTpgY5%{p)TEKbU9mY11$oM5V(S%X;vs- zUmHQJXTamtWn1w!S!(+l5vQ0+t61&$M$c{Ud2m`C;&VZ{*bjOiDi^FzMW>+Sqiakx z8K-*Jf)}jCxoyM!_Gg#&2Yac(`sfwBzp|eTOV%dlX}OmnM6T%Hp^VWFV@N_^Y$Q5N zFjCp3nYGgzIvxr8mPAPxC>7-#TBbfvWreS;^MHnkMMNK2mD`*UWXho-D8lDmVQK7? z;a~`1P-(Wltz(}V1OVUZol90V#LkEY7kZDFaL6?XgDlHBBWWmn&e-FGw3wcb#x`ll zoEi?>GaBz}o3ctzlz&1`#cdtdDl8lC$8pSw} zi$QmaGS4jy%r8U)V6Y9y(>WK;BfeH?U%E}4z^op@LGJiSty;x$zyT8zISz?0gJEE3 zkFg*lb}SV(kc`&T0JQKb*#NXOyxK02y~|oRSNHF)u;>#Gu=Vk!*YTs5?=`I%ZA4EK z@N$sWF(r!TK5Z0}mxRzpw!rYgPl$D)DaJvfvpCAE!+K0mZ8}qvjyXdXmV{KCX=n$8 zkFlF=;pwFV$b8g1jrFd=zclgpZTOFvW%UKLCO~gpw}s|`V~T3}Fd!KkdU$=)nsY)_ zgg5w*-uetrO9bX+4Q|-9Y>?dctYDheqSHKs*6DF36-HWuZj}#z_xZ9ufBN`xGUCyz zcl)sJuNz~Q;|3xJ<{k#8BuqEaP;o_i5$D3BQV4Xpp+^XXj7%^+H!KI?-N~uZYR8zj zFQmSJQ0L4>S9c^NVah<;3*IhF<2Iy1?_>KsvJK2H51ieXtrJ0|0@^%sK+&3{U4p3r zcOdfF^T-7D5`&}rQd&hPxY!9VvX)~U^nL^?_7q95<=GRB_c>E|EkHNnUA?`kzsT|* zU%H%+UbfpZ@J}-~Z6s))7ws^>3mS)+d2w&J6hvs0E-w+4;dxUhb09Pw_aHNu8>GDToljgy6Vq@<`0JY3hrq3o-77wF9I zTXoW}FLe?MO|KxxAG&t;Q2Ea<-U~$0+OS={Dlp`U5yL3l@0dJv29}}EUXa~HLd-@L z2fMh=+VOrob16A^J=M0UGxE9CqAoBVCUsfnX=A1Vwy-Gc0JeALohI~Kss%rK?e1&A zpZ7?cgfE9$bY9!5*|`wi0G>xz6knFj%an3jXGyyp8=#q>vLbM7wnmWHuVhE6D{%$~ z7Zgl9f^X4SX)+I{e{-M@C_i$f{E$w^*`qWT%Ysx&mEQHyK_ zS>AN+$b}6WEw+xc`(kjdAb>dz)Hdex=PAEtL{ZX%>+~9X$AR4TwSPTQ3-J%gjdlxU zJHP1|+N0O*K8E%MDW3>qZXC{qceLxpe{_2X&)jn5m>ti&kgq;z?k%9pD55lwV0KzS zdv^pHeYFPm8)qROv<95I$M7Dan6|Moz;Oc8x0BHwyd9GIRvytuFWb)yXP=+Wj3W6w zT2H)jgbg4zr~?XW?oB-eE7unB9>&%JAW{_D$6o9B$ZoU;=6L1gZV?1FOgY)1w{+E z6g`7LH9~3Kr_txZ@>0w{?mD} zp8w#bdoAw3ZD4Rg;aFnCbJ9bD8c0Fp#hXrbOmgz^Loo2YsSA zqmqWMTmVx54!e24-iY#!1uyMXzQ8IyyXE$~{0dSB2;yH?6v0|)8;Z|jumY#DS{U$2 z)dmiwK!+PIY;M75Pg+*!XrK}S54K71nV81GYm9eww!lrZTqKTTNbZc`K3bUH))@Zw zJU{(=_M`_d-fQ-xg>H|mGvVmLuD`7Fq?6ugT3y}@&d6;sq0PPkOJ;rL^049nvoSwrB+=sb_NrGw5S4lsPmO83Qyt+lT!vULVbJ7A>V zmIeRjySMLOlDMgjKO6~4E5XY>E zWWC`42s-MWSn{_&&0NI$w{KtWx;=UYUn>O;$U~GNjp88Yvu3BEqXp@LPM4Zou&)J3 zx22;cFo+hHOhCDDrnkgEkeuOOa0WU)a->k6hOA;xz!UmLUV@E6KdoAJS$CWzl4gtv z7{(kEuIffBv<`chfLMI?zLUTX9;5ce3BIqnwYVcg-C`X=WYDOYhy^^AiSu2zl)gc2 zT8Tp*pbK#lJJo5kHvvG-U9K>$- zM|7qY(6M3bl1GBjan{D1({2dG0(-wR*O9arHHJ}cHu!pjXA9u0u_7d?Z@;Veth@l|N0Sz=C}2^TYjG+eDDIkwo8gWiq_1; z7X}&2VdCKJbr^&b>WtcRT7{~p@HO5%jxR23;Wk7$yN-Lyf?G8T^8p=MIHoqQX!MFc z_HJu;8|Zvs3|=(BKDez00viQr*&v1tt91;j@dyP1crVY%KzJaZXS!+Z!Yj1lh2+4+ zEf*a?H}k4-aF%0{ymSG;?+Daav%G^#DV_Cjq0Clpg*3`-HSiZ#fcr(w&SRJD_O-jd zWF7Y8v&go$16Bb>lPB&1uAW0%aq9z;i$2!K3jqS<6gS*xTMyB602ZvF-W3oA!SS;> z17jXzRO`~TpJW7&rN^3HEwN?my6+6IXrCZ0M23+iSUUFXMnC}{Wefn;nsnN^V$#CW zA*!xb;-jtVyjIm{n#-Z0Ih`@E-8*LRHxwR|49EY0L{o{hW?UHNC7r|MwjutDPtR}P zytF}j^s?PvPWfsf#Lj9GB3!Xy#;dMyk_HQgIF=3gyE&O{Q>)C5o6$NBTPq5jPfqtF z>Da+wQE2nk60f`6ikuJp?0o4{t-mE#O^*uh9jO9ZSYY9ehyI_c0XP57_Du4EK3% zzoNhX+)#Vvjr-`e``I=9zhRdA!s~}tTvN_Y4kF(i4U%L#zOwH@O(7^H!)N>y^p1uY zu?;#y>-br)w=hsnVV%_G(mj)reNR$@WMIH|nkC)O!PyW7$a6}{?{a3}(lveb+P#)T z3OiKQwT9a@&ko5&uhkBy2|%5!b!IhJ8rYUkBxTl!rVZIsH;Oa5EvY>YzHA5FDgst* zk*vt%H6VEkq-l7qu^`qxvO!y?+heJxU4!whV94&5ESnZ)M*6|5%n1S`qaVti8~app z!I9(ukN_H|*rpn(0=MKAID@D*i2m3JcVXY+9q^PUWI4|4wGX5XPIe2w`pxs3A3nUT zr{_Pu`L}<2`_grN^!nZQV7{JDSrI26sCZx%WF|M90oV3~nhAqsn0K|jj(3cbU7=zu ztz@#cLNexDrt_S8V?t89jddVE(54%H$4$M*wTCBP1!UhsuBPmE+dG@iqwKZCxd%F= zZC4$j%d>&FsDOtaHJ5UT>pIU}j=ep~^$8UFp4nw$j3I0*r6~TxiHLT;wo^fK3MmAu zhM5#*^kmOycSZZKw{M^P{f{r2CLg_auV#;sq=nF(^Guy_wr9+a(Oyh8TTU1VFz(R_ z^L|Xk4&yPMXfkvXr*E2TYPYi|ut6OeKTM?|q@ff0hSP%A@#xy9wT4unEb4K4GIbGZ z;N-7mC+1!m8rtTW3))XG-WVmKF242*9lp`oKpjz+`wB(&C~_CcgzgzpcGq>nT2^1f zFCH{7pXC!8*Mi_=t-$feZs*$m{<}iR7a5i3H!rcx9=&|`iTtl{$qiDnphG~Gho}Ln ze6h9;%L0_hWXU+-uSy=ZhOhetQuUQv3BGGw0s|2ypiefgJu>iMp~Tw9u(H^gq%2cm zO!r?E+q^9$`8BQCDh7c#$V*j#GY6AnEJi0>y86}~YeE*=NhuhpUDDMHcFHnC_*uwK z#_CIfaz@H`CWxV+{u=641@M;QfJ$esF;4Wma_^TD>hs$dJ2H=6yq{mx@zZzJ70gm9 z#i6IqXo#UgSuiKEAuj$`C z|6m_KJ^7F4yoe%v^y=O7Lca_|H7wsm?W2{l?wE*eVPXd;_(Mr+L$(2!0t|**F;Q=e zu%icQ&B=~NCmj5hm^<7o>i~zDRikA^kBveXRUw|)QFmH%?9l?T+K>}cJyh{s$ndFnX>J^$K^vZ+FVf;gDYC= zrz4oJ2=_rbcl-K%^ZaBVKiZ$)Jb(Y9?)9;Ycf0-VUyArSYC$yH);JxVW1rbOFy3>) zLDA>XkvmTur?svPSs^q6M3-bV+p|=Vl7Xg@yOw$oCQ>k#$x{c_nIh6g*S_}T2A!Je zk~Z7zvBog?GLhz3EhoZ#2SC*`Frw`X)__aiB+v)#vHYg`NRfq!Zji6rXo`^Q!ooLo|1mBKC{r0^7Sl@lb_V+2ifAjW5-TH%9@P2sw zOCJ?e2AC?s)Bz@P8k!w6aG1^^&LY>J*r4s=O>;2EfW`x1*nwJaUYmP^&am|yQAd41 z;1SKQ0~U>0@RJ~`(NS19)&RC)L=0}pp)iE)NDg2F0n>+f3@}@|20WFh<^&f(i00&|OOPuzNRu|`$PL>Lx8AI_LG|Oeo8Vvl-r^6> zAIkplQZx0zOZOTN!1sk>#1`!mmhXZ6^Nu-1K-oj)Fl{8Vaa0^xVR4PpK?9GP%%%~l z)%^hP7d6*4Cqh1HnS-fmi|8~AwY06r1-8{m2U(B17EMP-%+RYKtqewaptnA1(9#*~ z+29WxW4d+xNtH^632rS?c#5dC6vXnhmg-o_ts}wHM%wOfMbmQ-8kmy<@v|1l`&XxS z+Zz8BdZ|Cyr+Df8`{<>+-zt6aZLj0qqb12cZQymU3&(dkf_Iq1$A?M4<88x(rel)I zn$4_d4TYUfd+~6OS`eCTRTMmj?%10U4ojW@tL!w{7-q6LYPam0ZV?Z?76m2{03~je zAj|l6i{1(&U?6bk28O60UdNUf7^K;NTfY9wBD?fj2azltm4dbyHBBZfUTY5R!yNq& zk_CF&o}40(vENqn|JM%|f3WZB>G#j?-#wj=?|*p8m&X?$y^gPy4WYq7DHTPJnkbKe zLL^FUdtcrghY7KgU!%G)trrYRb``d4Vx%+4VEA5^Euru#S|f2_Bf}{oV<{%FCbiVr z<{mU6f$rsTd%T$phHuQU*0l9~*=MZ!_KjB+njovLa$mN&0KC{9%|~v5`R%|_4a8WN z-WMNG>#A~*oyx%j=M5wkCUl{5Gohw8Kszf*sBdpKO&1;ZIez^3@y{<6A|AYWck{;d zW!EH4&feIBu=zUR_c2)g820t%LmbRLxP4Ecn;{ zjE{ohe?3O*=;0$Mh{@jGj&cY7eWgjZz~a{Re<4l#61 zg8 zSmbZKEd1!@dyVQr7etR1m;zIXqR97QSkv?}T2VUmZ`fZGBkHky&|mgA(BO6MMD+A_OH!pE_Ikpk8fl2di0h zf*l3`wnMn<7`>HkaBgk#8mnAS0@2EG)`C$&Fo3_{(YWw62okAERqHqqV^C!s91R;c zzx~Ai&F`Q6-AkjW4_>t!Y4X=oE84ziBJN(~2XK(x3iTIE1Arewu^P@u3_Ll(T%`l) z5)|}=(G1%h%ZPj6JXMU*{RT>ukJVaXLDhnbcGM_H(hLX&*o(2-@N;Do__z*d-u_6cl&_Sm&6hg^(r#OO#>fbcY*~5!#Gs! zV!r$2eZ>=HfLRn6qC2`v2Namy7crc-bmV~gM_vgMGJ}7eR)!~))Yzh#tO-dfBt+jDmIQ$3yXi-n~rw{h-`OW(mpVbF1;A;tB@VzB{ zz#x9{dSar?77$ut;)hy~)oq*>UW_muPiuWEuzCX>sh~*9U%WBhtu7NvnE zW-$W7RhpwQl9y1ujDv8|Mef#(7%uk77z-ps!ODjOdLqoxZ*h}<8z0{TrvJhI_|ipv z^y1y;fc5i5ZQRe8Q+rNqu#CX;t7OzhU0|4>ebDg)A`Su$*){XbwK{IR#sir2 z){arTZm8>b9Rr(Jz&{I};^T(z+5&8_;5YEwx*_z(*}H>Tc80}lFqEvW=wD&{1h%2U zn6t?ncdyJ3`tii-x+wbpJE5p$bjk^&MT z6iHb~uc@!CG6Ai&10girF3Y4(c+pl?3GQ?ZrhvI{W(}x&griO0`{cy20#4E%9D9Ka zV3mpWgya-ir#wf@ej0vz^K2H+KN_*3CQ(zrBY?iFv zT5XhZT2x@XzBF`30y8%RyHX$1M(?`;+~3zvSM?Vk{_x%Jzh2Z|eXx(uWgowLX~*>F z1-vuWeBB0<+Hf0yd1AT&axM%J ze7WUbrflSO%G9kZk_XfL;+&9e!r(8Z&FKrn^-ae?fzE(lRRhKf8qvXUb_0iQq1=wc zfTw)0W8m9VMD~DfC;+mfc^&gMyX+zDtfQwVkTua8hP2iC);O4P1pg1NMn$K*V)g2S z3B1RdrzuRwZIuMlm&m`Ql;(*ox`A;=nu0|AwtMqG|2w0qk6yX2m-K)8OLpnM{`dd> zU;j_VoA~XoO5#h!;Ri3@{TcT2rxwYd-fUiNL%b%MmoJ}_$3&rRHKggWxV*?U zuc%yhrv>2h>T_oEK2a>d^!v`f);WRm#qlU0X%-Y|Cemu3Ol@sqM>846k=u&@vZ*-? zjYtD-h}WJ_+3MWuI-!z5{$R|Z(77LoXGY`PyUF!3mMoxz5n6G9O8o)@cyBt zFU7=#SIM?3?iTKX2s}Kl@Tl+FM>`sbqY0svRdQkmew76|*T8sKpu$4vf58XaqqboN zSLW)FhC6U?O<8C%UWKCr4h8&-@|_L?H#eL&Pf6h>)8q# zTxjbVyHlWW?5S%NElOE_LIxDHu}(0|Y-p6^$?8NI>Au#4Nu-b5igxDDcTp(#fB5+R z)B6`|iH}{n*Phj}FIfFH&=Iv2nBg27*}l!psVmlK?J9zvkupbBpuISu_aLr7S%-ZB z+%>7s)iFyd@YoTba#|wQQ7jS~m;>{kHP0UK0Ns%a`#A#s!<+&^Ax`oU!1X#$><=@W z4uI5id(~l`PWYbnr92(cu0{g{f8Q1N1rWYV$hw zoZZdt3W(p^^V9R6fAIHjUwZ34dhzbxx?j#Yp_k4lTC}iz8hN2kH(Zs*p6j%x62dA> zdpo*i9oTqyug-^#!c|)6t4V;eSow;yTi!{UB;ejI7e0 zGTPaEmd9vX4P;)kqxcov3_8AfwRRfcUC)2`0THI3`sOdLA%Ir%aCBOTYO2Z_W9K3g%E#DKg&q~ax&WsqV4J+h$V8a*`Tm_PXU%Z5U0_DJ= zbIuht4YDEh;YQm7XV`HHwl<8Gu0SXuh~b`CM(CW^ZKeM=Zg1^fR6f0yDSh<%y_Pxj zbD{P6G96*u7u+t6aF5Y82=Le#qobn_0&ouwNS&Pu8T3|74IbF4aTFXKBotsdoVPh6TMh)p9z6E~#UH*K3C z-$$?BYdhaS4Rc|-XQh#Pgm7ZlJ=-QlFEY*suU2|tR38Iu))Xk@*$ zJ~)xoQ4RpIBl`4qQk@krTAVBxSRkoeTEuTZ!}Op2_$EJn{}e9L2m$}7%LYLV+LLr zsEq=6Op;Rt-#JJBnMZeC#%HZjK$p<6b6Y_ifTd1d=$H0|Q%Fp3&vTp{$PhX}835BO zA3tY1BJkv5D5Iya%og)lk!sH}CIa#mL&P*(=iWyS0*BHg<|I%o$x);)%+=ji5dZG4 zm+hrY>4R7Ac6|A3UAQAHrA5eMPTxcUr5?Ug9zDk%SG?R1K?ZWA;Sp-bIob*0pcW-- zVw#qx%NlbIIn)l)mF>bTL%zs#f}t2duBSTsV(F^ExASwW6CNhD%RRMcVO~&CoT!#? zm!9K*;P~hhZD(8<4(yWGm}m4kqbrW5wY3U9Q;cTK<+Jo;{~T;sTjj{LJCy^i5Dzpq zXPw(`?Qd{ZKRhAW^va|A==J-0UH_M_kM8H6_Ft~v&KChT%qbKgMZ%moJFM>!OA3w= zSCN5pb#DvWjdg}wx;BX2pvcVYwqFCMLS%&qI=qS2BFh-3jw11~jF4nNkiYgCmELhF zE9mz9++5ccR^#dfHW}#!qk^YBk^FD03TzQaA^SepQVMI6;Deie#!B$L4fKYF>5Wms zs~MjDW*k!oy0WlNVPMvl75J8;yZXHA==}OGi}s?l^Ra99ny7v%s*MvgC;V~^osz!0 zFd`dJ<{hNLFc~z>x$`;h0q$JGf5Pml$IEB8)i=+^D&Wpc03=6Q$;JsKUEStv?Z7t9 zwHM4#t+(5l>4>zIpCcx-6G0P#ckHnt;7bf|3Lr{#4isc?mtP7;9QhFpI?*Q1kZC|z zkpSd7X~*i=z=Eoc2ezOku@+Eg9+d_kwfJnek;K3M<45~};IUJ>M1_4fu_qapAc(PSF_i>R$NfY3yROVxwHy%-ZY)>@L5ZhaQ zG}yyog!Hrel*28_FbBaM6{)%DVATm}`_$g|(1iNdRUIGOgVx}LQ1fp3^`|v^X_W54 zOLv=g`dY3C6+u(Fun5-3l*HvyoUT|bPz2D`u|x_sY3lAYCz}3J_`hLiF7%7gs6K6i z$T-?LK#tSeTgtYfb>SNp8r1Z3^>e2C47-bl7YGA6wpw!A7HEo$306I5Tc{0~u~Hf0 zhplKfG*{Q6g&k)0#I%2nnlYDy06K*V#i6xqNYuC(;6Sxm>lmKFd6MXy4!iyBCH?jF zxPGkf>Q677eIC4a_w<)9_<=JvzG9o$L&lky@;NIfPHAgz(1I-OaL$SO`12V#)RW4Q z$_=#|>g{M-TYU+4b4BP`fI`5}-4CfAnu6||oe>zbN!?Ciw_($7>Y6@!?S6hu|FU0N zn4Ye}*gb;Od(tAbzOMKi{GS*DnZdR3u7|Z{T-bQR%WjI&JRSVc-gA>x*`Co&fidQ> zwPhW(D{VO_#=gocwcGB#Pj4*%o;?c<2MkVt`(3=>W=V)@bCkk=LE53ZScLh-YFqv{-$1c%@W*th4q+uX?oR zff02?&(zARL(c|T!u8ghhO8>|skdFb`r-ZWUw>*Jy?FOo;xB{hM*zA3|HcupIGxL4 zoIHT;v7<|TykCyCQ;kf+}eYbfre@+{Z!@fX=;Qp;M!Y zFD0-F8*-UO{R}kY2E1w*G39osrFpd$ZQsRDzo}#Fqu1`WPpx3GH{$$T@?A>cs#YeB-J(TuKOW>p< zd4p-+fMQ0!Och~_D{_ezUT8JS3rJp|X=uk>Ox{r_6~_3Rf`nC&u8(xG>97ke1&(=M9W6}0Kr^>FC1einBJTrZCjPhzV>O?DA+2H=+(Qusy~fib+m(fw2q`Egv(^nCT8bhli|~7v!Yz$GVsOb9HVpV z4d^)4Yv!V%%#BYAvSn6%*~FhJot{XTUD(3;SwA~whxcO{B~lXK@?PoDYj?j_`tqdC zt8=S(fe(v;iKRMFutBYbdaE2Q1$SsjyQF>El)OkMYs##lGcT9G*|5)uY#mH^N%}yH zR!(o?kkN?ROfY8`4tCtexRV8bTd&_oFW&7%{Y%!giLaTaw40AeM_$^I%APjE36>X( z_~964h3Ql((7NH39S0B_OgY)9#*+JLAOj8-3O=2titRW{6Yrjm)dp#j>e}|O-yUkd zvDfdTSMRl|@Qgxm$j6SR+7Y%UZ?Wgm7%jP@I<069$@ZLnII=U`iLH;xfN0_^15}tD zjA_FwPikAbvi3THk~VM=Z3i%b3@&?LXlHA?b8UPp(%nZd+txY=WC>bk7Dobf_x4Tz!H6h+HPrsIh2c#=jh{hpu~tib*uV$%_M0i`75-V_S#>#tcZ{F~w^_t!+kWUX6EK33{gc>4-&eOluH`b$< z?f%A^GN@gmhNEMxW`@Bu9T3oCtQJScb`URS(*fUe^Hg6sSjCEw877e#AP|5LyeE`! zqq`}=g2J?%6JoT!4mw0VlTqDNNAb%#wgE~=Htukb+ot!oa$`Mu z+3s&FHEQ6DNwp4!IUuJV25#{MB)e$g7MQ|6fSh+h&EG~pfW7x^gAp$t9z&L!9>S>Y zZrP-_Eev=}N5`WDET?rU3#Dl!h_IjjdSmsU939~K!lXz*l?PR~#zV)M-jC-zrM)N6 z^=Bh0D3|xS)6_N8^X#=lo7fm|)3Yx!aM4et&XKzjjdr?(O+-i{hN^FLq7nM;w^q<^ z=Ei#PvfbZUB_bE>B7g((nvFx>p^y*9lQxsc%E@&loa+(4I_SMeLJNhW<4iA0D<2t3XG2NWntI1=R#`aEC1i}QEm>x@&zrGy65S#@KaQTqYEJ6O*k-BJZxh{lrMWQ*g=PRCK= zs&-CKQC<7QlmzkGm$K&!SV2)5>qysOVi2v05Gfhgc4Th^pzmzeh$=5yGY0rKvmX|$ z@et^F7-O_epvUZ`#h|YH_DrRI$kwJszWda(*wqxdI5Xu@zM`ri-`s0lbbS&sFdT8K zMWZ@Z^EP+=PyhBlpFX|+jLmCaWJkg=BVsuQ#Np&RqsnBpwvfW2SQ1tk zRK<92>8KNWwJ7eKN4<@WASfoeJ7TxnD@7s?s}cHHG|t&NXBl}0@DjCScCa%dAhvg# zT^lq(AkShh%NG95T@@nu6DTLUg%#qt%aN8c+`h!O^`&3hclGYmOZCD>uiMvK>;L=9 ziP13~x}b>Ke8Modt-_Po2MiAvSEomY|r z&edrNmIU2D(AW5%6& zsWZ9=OA1xlG~GK}^#&@VT(cHy!d3(55-dd0r|I^Nay1%gyRCycz$Pc+1klJ0Ib@i8 zq)c@Xil1k4O$uMBnCF93u$!PTe9Hs-Bd*}v7Y%8TUb*`h*ME$=OMb^+69myuo?uFF zW{w<)SYmlY%zn(qTxfI>^8eJ)*=LxR6FkeZ0jdQJn%XMkKp1hQH!{#?!d~Zy%ks8Y zCAxN+xxqs`$}m2Y+y-kgPuUVVV>D;ACB>oxXe$pP!$~X9Kxk7CbA){Y^8%UOrn_Ez zUiATc@v=z)zTC#_o-cSOohQT1)R<@);*5ehug+dI$Jw_-h5yN3>Rdf~&F*ij$s&mO z`vH*~!xg(A8&bBmHqv8Couo@_RB{_IG3^}L!ON?|l}>YH$B-A!lStqz zcJ%4}Tp$rlgN){uG=1}59UAE~9Jmy^D!sTqhkf-9ExJpj0$%|kogT2v0XG4<7LAVR zs6ThmG4|GCnz2kSihgWqPn~$IV{9GUZ^~KlLqZjW#>iva};{2SEfoTbI*O*&$l<*oc`i_`E zm}>z;htf#L2tJt?&GKLj62nF_QB^A-_8o)uZq+#Caz8mRkwF9K8r6iKx+$_DzOqnp zcF+iJs}d6%N{Tj-OUgyC)UEjZc4(MmBG6WL$iT$&Qi;rkFAb8r0|>;a1{=MsivORw z_sRJtNwT#D=t_tgBjzyfmiZrZbAw&503>%abE!qE8+F~f7dF9wMX@gQ#8=e-T|lD0 zT(XjJzBT9`WLAC|8NY~d_haWg$J&g5C~4K#r7?N817@eiAkUiKdp>V@g%XdjsDI}a zpMUy?Kjr`WS6|!z_HY0CpZ*Dk!Jq%*Km9Hm=#RdQe|^&auYZ5i(nA;-GIxT!ZXF$~ z*X}WRCXk+q+(guZTXEap{X`y!ZN<6ZlAYNTX@3|Fo$Wk>^V+fSj&_APit>H$^>xsUZ~8HSR|!+ zfoxQjF5fuN;AXrx3=XzUlWD*IeErvd{-^)nFW4V_1Ap=(_Dh<;Gy@J@8FXuV-%Gab zPTq2dKR@Tl)BE~PVEs+rz3$iOrA%A*+j2B7n$GV#iQ!uOA&~%>Qjhl7_jtsX=6QiB zjiUjx{kJ>(zt^SmkG_q+vsC`UU)SF(l^^*f*QOfvtjhC6Mp^F1p1$a^m{)94 z&4C8q);Ny0sr)RJ`wJ0MXW66Eyll81nY9od?FI>dw#L~pgn{I^lyv`XAIRU`r|gfu zfxq)9`w36jfAJ~HJ^Q{yWuoN^p(cAROt15G>lMFP+alHGiI^7 zp^j3>fZNQVovz&^etW8PQlL+@-sc?$6*KX}9dFlx9x-LWfbq*td>dG@shF@FzRbS}hQ z0&&=uzp=hy<=>=e{<}Z_ss7xwrKS~{3R0o@5aJ4bX6N~P)DmfUhXuJ^RTE%!Ax*-iB4C1(I(Su zcX)`z&|mZ|<9Uzo9ZZwgZBMz)b~{XN0>0U;HdQ>951$lOgXv9o`|W=J?{zcwN8iT3 z-HiRw=aAoQ#`?u(c0Orldr=ft<&H&Re#H29ceK%@*T5J%#~t|&jjxZlVG4M@DR`nv zl+A?L*c17&d3$s3Gu|CCW_zF>@YFQ;JVu@A--H?B)^gaAr8TLm!WdG&Zd&-L^ z^un?iy$oT<&Ly2WairrZ8E-wMjqp7=Et_I`>0PDGaV15U_gAZpL3O;_QR)b{sB88^ z_e#l#3BF=Jd$*m_TF*XQf4d?3dohRo(YNh)T!(WMevC2pjn^i5_1qWW@U6G_YbtnE zDP-GRhx&R@^>jqI+`Z{WqvUDsuR%8I=o@dBt?-_hCp&dpY{Dd`9Jscr82|L*{4 z{$+kNs7R2lNhb|^<-D7PH==qLJ*(r^kz2c^_(hWudSKE~~>{)P?nck*EU(YNid57z(r?+;dIgc*IgFn!CMZTS&@ ze8{wh`E4iK6&v&hA8pmN&_K4G4o)oi%-UJ&VYS|mDBHc4ypxSvJBtO}fxbPi(HZ+5 z(5*>Y?t8F)JyZL+JqkQQqf^$ZgAySp)?(szC>EUJ%cCwb4TD-NBoc2womr(FK*Qi& zoG^8k_6}`r@zL+UY<)6&9Xi_CKr(;dUgK8#Z3Or4<(c}UZ`Ap)NnKuewL%WVq)8^G(GC(HgJtM~mqh;#uQ`N7U*Lk^zWgo{DGLQS* zJy-Uwm|k+N-+rv%Qb0QFV9Bw$*i9wU2Wd}m)+P?BqBnSqT>ufn0veYD;@{x{|?eLywZ+xjkHU}n+y4%ooTzN68I z+BrjRdYtd24iK&+jYJ?^;>VwfBs!g@E?57e#a55tG8ii zd_^m7Ud-c_^i{03A-rfG>BnZMx48xU)LGp<7oFU_j^tcNtxeg~GTrB?ZQflRSiQ{; zp|ie&yLo8Iv%&Yx_r1R?U;7{1{wv>UKb9P1nMILadq?}Eir31|n}oHY=lh*&wIu}w za2i~JybqH3dEsNuPD#wUrB~>YGgVhe|0eeCw-6Wv)3pXN;Ga)WG1+_7GE+m2SEle3OoJ zli3kZx&@`UN(BAvo2a$kzWu=- z$e(cueQ1;WD8fT~pR45^Imk+5$8OpHTCD6;NHwJ*W{-P@bN0F~pXXS?LcHYZla?Nb zZKOBxYX&#ehI)V%n2j8^>Y>3PUh12eEge51%hT?O&0VH9Ezv7?$0d;cn#sKGU;_Q@ zRib(Bc*oYDmT**$b*;a%vDTlvzKY)<=4kY9=YF@%xG(oQ)X_r(_Nx_FIw+BKZwKuxMYSK;KJ2y$8DqFrIJ8~UTMN9V$(?5&oDK8 zU)lB=h|Z6G4opan2kH;b5`33H&(@fGMa(vVVzIv}DGbq!RQZwZv$GqU;&itzS!2&fk@aPr z%p4>2edwHKV>Z4$)&VKKipP|c^7)-}-m{ak`)F+9jy^gBkdF3UZ69HqlgQ~qX!uYv zy+VXrM(2l+b7u0~zjndB(`SawY~X6Vb?`)jC8^y$r9ECxhtv3hVW=7Tx~$gJ%@%jj z*@0oIzmGaywZ0o1ZQ9JaHB2r% z0JE|VsfFm$`@1sc*{uz`?kLlWK+=(t{raR#re3tq2YKgk+iiW?VK9WQ#a)O^{8+|K zt2QQ&G^VY5)u3-sJeq4r6cO!d$-zZuc$EYAI&2jLkU+HXUcRzw59zPq1s7N5Kx z9|3o?C?+gdIncsGdyahNbVKYh-k8(6*QKEQZbC$|8LiGS^39t>vUwk>nsY$0DF;r# zetxxDD0^`2-M_h4G;yC3{H{=^wO7z=oO--bSFzmTw2?QtdQ6~?$Z-tVC${c-)aLEW z8$q8CvA5;4^Nl0}If~{8#&Ta(m1HK!ocTF4a-OlhL(@Gfd)8G4UJ&y=Nd1XFV7B*O zbgd&NR~*P*?)*$V+ZNA1Cn@JGpGp+x4=_yAuoU!3fy-X)j5?5#C<3jLT<6 zOsZvBy)un4rOsP*h+oL(6u_Wd$94tP<&&-pdXsgDS{=5PYi<=|dfat=NR}W%v9t0) zXdt51_qPzjvsN0kzf#|iD&L200*NAXGu1s^E8QC%>6d_*cU^C8=OEQIhU`8c0)^?~ zPu%`|sITA>*1cP39BIZUX>?7L?F@69(_8qgaQbD5XHx*O%6#zO8zb_d#p0e!>g~xSKy@3jW-fb`Hpm))yu!f(Vrh@&Eo+&o{x( zdS}wy*&9$r{kqX^T9fxRWL95ed=+ip;?1ROer?>fS32Hr&7|qFpXU0`u^u-}r45m_ zS{WTW-PS$%&e8`Na`xNuRyLq+GCMB!$&W#;)XrIF3e|`E`#@u~8G^J-oGVt|=$dto zKhAyfa4@$H7D_jH=oo{DA%yG)%g>v4jn}2&l<8A1&Q^eN%-aDzYDpOBq*+m|IINGZ ztcr8s!M$mx-qa;;er>qi#0{_gcKPZ{jtixNB966vskiZrf&GE!KG7rQ(tWyA=Xa3P zR`_J;Va_d&9m|P%gDzirh_93DCc^8lAI_9@g>mNyZp1>B{+zi8l3a6u?dvoa(EO_gJ~SZ)A;@S8n0c*b??rX z7kF69w8hPe+A^2)HqxK995hb!stNCEaEKe;1Sl;P*Oi~oxKoG8Wd+Tu*)h#_(lUm$nSRc%;c{P4gzD6sg@*TeiA+mRwar9dw zbbJ5WyXBB1KN~!)=Vi=^jye*L^pV%i%Q(nZg?yA9d{YmIN?rbI(Ii5(_WtIgL= zv0%3gA9xIku~mBBUGoj+On2inyh8QP8TL&h_EB+D%5N8X`?f19%y(lf(&kNwL`!vz zMOHA+04MY_&Jp*}v%c2L7^K?p1q?l`FLRUH>hiS3wm>*+s zcQ)y!;L$r_DeG&|++Od|0br`Pl^#!!)N<^tFLG)06U7xzp7I5%H#&?u_dDFGA6a^q z(1<|q7`CkO#ralt544~~SKlFljUSZRfRbqE5u z^0_LglU_;l{O)0wD$sUMqkb}7@68r--IahUXj<>l7oaoyx{p7a;Z8QN9a|7DO-%b@ zd*5l7Vfji5v~$b_WI@{eiUwn#?k!!u+8dvpWOMKu+LPUtcmEDK^b1=wcKW*}7>T)7 zKS`3&T_!EVCbR9{;_P@;TH zvuye87yPcq2hZB2c#F)>o0PyA1myKtF3$3YSFiD&$f(&br${@;cJJ+_bABu7bpCiB zw?2^ly^pQzJU~o7OX4;vb;laCliyp5a|A)m-8yq5S~-Q6cp8nB=RokVmP{snM8EQ6 z^^Y>mX1sN4I*xNT+rmQ@blVk5gSBE$Ey}n7@8oR(CoJ0n|4gmmz#6ssr$~#%?EQFA zlN1c&l%sQ3%|*Ts&Y1DR+a?%%ZyuH)gvzBnC6x4av0+yCa0^Hqn!Ur9yN}k{Z=mla z5X^g(4_iw%(%*ru!m3tg4iSY{mz%)RBtMRM^-cb&~0s8 zv3A}(Qk{0%k?a1ko?|_?4u<1Ioc9iu)L}h-#w9d+J9ZnV zx-^;1_CBJp!gk-*XQ<{r>pZ3A-ouB*Y4wh&%}E+L1*`Qm2C6n~t(7rq(-DT}D0Iz1 zr8+^Eq4!a?xLdTd*0l38E@3xof+jrQh17K4(|L5i**aQY%$+tP<^T>CEmZo!dElQ2bH3A7wOV#&sY4M(qsO=jg= z#z~E0`m=0zfPVTjE@8QZ4bZtWIw!t2-#weE^K_Fj#Bah74`0}!1=rrZo z8S|wJ5SwWT*^M3()j0Cz;CQm^2o)w&QjLW+#7Q~>gE~P%@rrzNCZQm-eA=Xu^5q>G z%4PnHOX%M0E0oF>!=wD%TCsFrx21C4m?!MM>nR5=TtP&Qj*M-bGVgTQO#0?%@})3X zjLYD{FUh3Webog#_tkZ^ol@^Bh2dz)ccJ`UVI;-)+j&?A9_5guC<3=o)_aq?$G#^4 z_3j*doqe(;^|E?=&ZejLx^$<*<65NQ*wPFimggn29Df*`HF9eD&$cVPX5t$e-#mVfb!+Nn7cX0cHq zDWKf=gVrARDSC?}oSm8B#&}FfBxfW>yG}3gI=}M#euJ^#MzH^eylvh_|3hmmKXV$U z{kjcWpynBEl)Re|RkWotq8?gt&-8chu4mOJxYT9mn|bNPgkU4ivZODI%$EwT4Ng-f zERRk~dOe|62_?&s@lu!C`@Z$H2GFqXGjGBe5#znD{Vq9m*&$H73%HGpds<5sgPz~8wt$aP&pGiyI7((CCAT!vhmcT+; zwIzj(8*kq_vTgF0yrO>=U)$$+(hV9EqP~l20=75ZLf=eu#Iqd7;5r8bzPqmqladMhpZXjB>cTuO)TV=olm=xkU| zW9SeE%NBuy)-oq;W1Tsf^x9n@7QX3?dz zFPW83)`PvfQoy6xR$EjXVlq~r&R}+HTgX)tF(@|H4Uh2ZtH!)!Q1dZL-$sJs*!M#$ zkApNh-wJ2OaMUi|zfqa)?}BV51&%h;sf2qbj~r{)frd-dF+grs!mM`R&tN6plf5t8%WiSW8*AHnZK zG!xR4PCBSuU*8sOk2y=nZKMhraPlnLHTzPz$ReBT!^8MZYn|yVbKpZ)C8r_h&@<%q zIFuqCMlM=OA-muE)*d=`gpFzBYkg2z>_Hm7BOsH*y}HeMv%$9OzOPu6LXcGy`AvUg zyUXG02x@Wk=c1PONv*0GDw$?XAK=hEc)AIZxV#@RAUx93% z3>`l0iVjwiWC}HSZWsZL^#&LG24NvIbgB#--(PgbUk_^-AJXU;>$jOTZPXp$X4I~? z79JJF3Ut<-dp4qQsZ5cvP>i7u{k&p&E4V|8c)4d#T3Pu6Xf-Eq=w(#);rpya~nv$<~%kP8JBQhdh@Ysgr# zKC>gxU0cjSJ)U1|JB=Ad3|FBWPxL$fH6}$@&R|YigM5eGiy?(m70nb(>IP3QI85HS ztIyqA>p{9Ihia|8*ra3|yNi)C64}Lm|B!d5<-GM~yNFyDZa__4Gmu~Q;b3^9U*3rR z>RZBV{{zRGxxzqvm`$Tg0y9$S!;Y5 z`0C6n?Vx(;U;`Zm?2%jZ>y2O+-1wc=qqB6j_HIq-Cs&-NOR1<~6Q{xwg2m)>=#19L zVKLI&wFF5}immgwta+#Bu-ns0nWmm2_ zhMsZz<@S)?Rh!rVEISpn?zjsy#uZt#tM1{3<&g<4#lqm-3;|#Q3)%hq^Ka)&8n&uW z`m0l}bGRSWsmj9x4n0){E453+NelDZ^Sr|Sb@#J_l`R?X-vJk4wPRoko z_91F`{a{OYb9ICeQaF9wFQoH5gY13Vl)#|ZnJe~_csQx#y>!b3m4VB?#rg;Apnb-! zd?X%S=04HiF6XIuhU5^7f_`|MileR)GVfp7WZ9CTTp9ft~aP0K0aajj9> zJvv8Xh4-7s^X-Z|X7ATq1A=(^K_h)<(JVPS=hiLX;j$OKneS&@0z>Fn;{pW8-q5I8 zH>C^j?H1?syYNVWI(LKsB%gujxQiT}*F_h3#zf$MJNmbo;+=&Q(+;N*tF|$@48NoU z;hDU^a`WP6Tmt>jLF^P#+R+mn3(jo*%|Lt^qFrA}{7h+!8w=axY{*r(TrlOv{)9Ym z_VvD^sP@(3MAn=fX6`y!q(BhI-lZfemCWS(A(ueVUy__0C!8^92I}#Z7BL}cpR7== z@1kB)E90&q@;*18SeL9}XHGZ1YmE)eWUNHoHN9&eXJ4|t!6o)+>SnKJnm_;Kt{-p- z`|M(brC7yRtjEOf9a$r`W9srj3mlm|4Q#%Pv+m-4YEvtGDR#$@*o={OEHFZkoyKyK ziU%et)ugPGfNJE%dVXa9m+3#_5)^>G)3@>b!}ahUe!8)?7o&|KpOW0Y9nPvSa~w3&llY7zja_#V(azgB&JCeF zf^7o{bq;xK2XmF-P|VD;92m4xBHxF&)E>RPqjaQCMG)#T<*qj7ZMil(RPt(b?Z|LQ$GGHtK8NJA56+ z4N)%b?e4ivX<=@Sazt)AjD#~I@iECOrlp%UU?ByD@39};ks~&C&YUk3doP)>p8npg zT`p_hH8&-@tkz#xgJ&VkTNopU_n07%4{5hv_*UNTW z`ELz5P44pGK_b$d=Nm3BP}Ovb(El)-x^HzzeD@d`9|wYiab8xR5I+4vgpbWZx#D$R z%63-L>nCI9S*sdoJ1H#Ir!~sw=W!=!uh_-6s72J1VZ<{-u!oB_JmZJtJDbF+s8{a| z)h{;6F@+8(KV6i4R`{lAAhvvqwJtrB)DKMJub{*dA;lLhB2^DYOW`f{d3t!Z_jXrb z#pIfFuOdl_DXYVc5p2HancfO1^+aG4Y2AkRx{~J`J;RH+JAH_-gweujDhN$GV3lYw&kVkOb3ozo*YPc}00dXuOG#d?l2@`MxI|3-_|=B=$Pb zSV=hctJb)E^&D?1#}Ok77jTeX`4-D4UU<@`x<7Ik!ex?4xWGwrw|#J_;*O0kX3Zl_ z=$ywNy-}CkLFeYA9%Pc+aYfl|gK;g@*0Bg0zOnXZ!XdX#2U>EDu(zFStRSmd^)oJk zy3-h`xTG3oH>8iEoxV8?AD9L5u*obEZyq`lo%Z|R(f#yRL6S*cw_x4&oafXSb2cCM zluzuGsu!+bFi<=I6!f~t_>M9^;1Xu0npX1-Hlzt z!B6YV9KU%yZGU}{(TFhN;0A3pcK?J-+$1-UfbdiGIZ{r01aagur2l|R@JYV-P^G*X z)Hc%Wx68}cb*`6NxrysVmtj~X-lTJ9h0RC_84J?zamLxDYjh9=b@?Luq??;SJRLPY zP^q&MHE#QpwEDMe`T>`Kwsq!m00+g|I^Q}}^jII$CkArakc0|IOk>%$VI+|g$=|{ zS+X9XdW8{_@R7x&9JV#lFyf$(t-j-;iyHN^s?ljW`j~ZC2eL5d-?Oj#nMDeH@9Y`g%f$B88M0xdu)2*|6Bm%UX5&8oIZ>DD@h zNpSV6s$%@nmK`6HkgufAP%b^7Rf56K17-51gz@Pbl;co>29ml7%B_sx4tY#`^p zb1Pi)5F!v?`^{4o_YT*LU5ArQs`c(qijL2%Hn>}p{m8G_*V+=v*AP}mKSGe4$n~yo zX9pkfHhS4VN6*r0XYWseMYpZXt{1%nR2+c~3bA91bBwZ)L8-Z!5IhEOaW=T|)ot2C z4Kf5)?-TdDE%9vCu)nuu{)9xgq7MyLwCW>%^~q&E>(AKYxtRM28oHUz66(<7avKTo zt|P3lf$qn!lHOER)3LwXvn|^jM!?z*zF#I3Od=TFaJXpu0-UxhQv%YOcmHr81XONr zoc(Oo+%SK&wC@BOgh(HciLPX9MIioq($@u%;k_Yf*R$V~+lJMBYcW?-*io%fmN}Vb z-fUEr1%pH?0Gjn$_6>&CT{a1^^yo}I+X2`&!VmP_Grh9k;WC(jxZsl}&U=*NbEYIs z>fj8HQvOqpmGnI~bIF}M_RVcVVOdoB@_v+#aeTL?Cq5JMJj*=K*d?U_aR)Rwha1mH z7>{|Nn+A?2>LC;E8;#hQb=a6NzVDa)F#8kOq&tyMdzA*beFC7Pn4zsTGd~J*4jJpl|AP1GqeiIABy=1~Hs_$y((1hXoK2HZY zz}<#3ExhEsOm&luoE^ME05|Qj)_1s95k>!I67PxCiw;c}`6iqX&^RHXht5r_8zbDV zcdz`0=FSrcujO8~f!=<>ldV6v8p0I1y?7YREJj zSKuTbK{p6vo@KF!V{W!3Ho7_+G6Ts_I0ZxE>YP#rB<=@Hyy?C^)0o^1flGFZnDKrY_!Cx^h%oJsL2QN9lD{jV%1Fr?(Bn z*6>;!qGvcpnzZ1g=y%}e)%ocRfb-uVko;~wc|LD{Z8Rm{CCx1gTwqfoYV4rjH%(N7 zwFo#6f%@WAtvgA19h0|n4O_a~2v8;Ig92NZ;CO>)xlOZ)GXp-zluqq4_Lt4hJtrRl zYPMPn;iNtqHdrs~`F$5wwiY)ILXb9Qv>;k;Q(JSM*}p>6b%EM3+j{+dwwgK*H_Iet zdM<2rkvMzpPWXzjw+HsnUS9V}?RD4Ue0N7*8fV@*SBHLD)7@*159Yw%*)2{&E zY3uP@ELhuc>uGx1M-P5vAnBgtc>{B?pWbgRZcC}TuU|!*I^;1e=<0JPIV-&C1r(_7 z^Brq{z$J`F>S7RiEb^@BeG);KSOaI z?1fN_R+T()eVmkMvKlPZCVl&ni_iCdyrv&;34P+*s%{kxkot6O@O{3?Vd7fT8auH| z5tgkE_xiTSM0>wxaY0`jZ-{o09&sPTl710j;H5zI_|T9<8V>!!rxj#jHp1_RTta0( zL`L6kPxM5E;1yQr@<=Ax50h~?g2{$ZI?Lo$r@&LXb~eR*0yro4bZ6FV)VX$#i0e$%rAG#A>^K>b6Dn@ec@#bqlOc1 z51!n4+7UohA(T!W1X?>9l}(xRB3Y%v#3j1>>RAoZ~1l(4g+as*kvo{ceIiGQ!glJ4QV#e zrj|(k!iT+Su?au}!;udnJD}f!f;iF!G1vz24=C`_ zXRP&@)Dkb5bXYy1n1)p=3!F|+7}L&hduyyaDhTEVj#nsk%qGlwNuTzyILPlyHm$7w zLhmfjBg@&&Do7b4qlE8ipLLf|xvFXb6AXC&gSvsq+K2?YZHInybe1)1(|RI>xod5K zr;dQseK;n)^`(XD%)pKgswKIHA^IjxSx!&1!REJpUFXvJ%0$9rx3h!oa1q7C+_o2o zI^P=%$4${MCro*ITS`<5%euXZFXY0OkswXM(ga`Y3yHfwj!_KbVMH#%8pj9@=&y|% zN_D+uIBVxhDG}@NASooKWgUk{2>8KBp1dpyU`%GQ@yGs#f0k40m~&0T%h2yTcKSxZ zxlOy+(Z?Th`fzy~^L$0jTtZ)=0hFcfJCzJaUGm?mUuz{@X{Yf2T-YdVT;DBXSW5wY zsaTRr*>Xm_n|nxuECrto*)Q#oDS}>XGjTb(c-@WZ@0R`IFW}UbGiu#k0*H({-l4(! zxh!Ma?$OVB{q0_w5g5icP2;VihueOX`QlapC@}aVKMEKDETD(GeOb(L-c@?U9vw05 zFo|kkI056t9DN6j8ron;?tOCsVu=P3QSXtX-8HkvmChELlgA^{(e|l*@>o2ZR)Y^@ z_77>b=aV^{_jV$_*jDx3z)n)Ix~~4>vS>xod;Xq5eVe_eX@8^L8fUUIRnMwg0#G!vVOvYm4Y^-?qcMmO(2vE?|6G}w$Uh+XyCyOwb9jUi&MwBH zZ!7j0#RKWP>z$vl65Hi#=+p!cYnDnSULO5Rt$x{Y_lZa7Cw5wn;!J=4I4Avm7k2{qXHA8Uo*-3 z_gT86USmcJP8yINi?lTcvU&7ue{o8F#wFmNc?pe)p5@p5eqLZ8OEGm+ZK9*&86x4S zL!vSx7)nb2Di7*=&bPS7EoG?)0 zaAe7dJ!=o!nV(LN!$(>vL@DpVG|+7Mej`@UeGxF7rcM2brz|mNEcEt`Xwo-iv3jH7 z32(B_r(S)q?_$d%2IOzhuEAF1V*R}JHKx&mRb;u_o1aVlwM%K+q(4vRlRgQZ8xiul z?bm6lkH|QQtLD{yM-kdC#;ln`hZ9|OZaTpr=3~c)V^oHd>u6g#)~W%O)3E!1wA>pUD&CLR zdXkUuV)i*zBj)}}{@&U*kok^QwX>f1mvLd@_dUfNOo?p6OP1RaRgY$C*}o9* z+S{<(Ww><}P;f*aM^JSFsny!9Njc?!Xt{LuKEJHY54eQSG%qdlc>7SC1qHsm9RLh( zwIEC|M%Dlwmw2>iY@i_*`Y`XI?kpSW>W9{yY_OUwYqebX7qzNe6PN_|^Z1_TA6jRA zi}eqs=R z*t@U(t~0WI7%dio`li`kZ;x}vLV%gyco*Ukq&eU~zUKdjL2%JU4frKxgeLJ)KFiqohk`iFqRX^jpM+5wpI|VK!U&1C6gf+C)oLF%{7a8%$fabUk5e=k1SO6mwBcle zQtSawSn^AJwZ{hF3+b4*g(=Jg-I4nQrY`se*SdZh0SB$g}rkY z#p4}r=ICwFf&234s9bnSO=Ih)FTiv4S$k1enFX1(wD2l#$_5MIWCxqFj}1DGfD?{# zowqnYw3I41;q9t{(4*>JsU?XVU2ktxAjW3+y+PMBLS%%n$!dOwdlOiis0T&ESbHz& zv~0ws_c>^|YbMG3Npj(~vl>uauz~9k`=dKf#>ERVwy;&lJ8uNNqNAK(BTAFetMMFz zykw_EEwI$jxP;RU4lZrl>@nO20}=e3aBrefgw_}X(~k>W0t`05YkO_yJ{04Sa`{dz z48>6J{0nug*!FcG9hrXH19^x?y)CAgpmgIG8ysODAZX05`9^c*k_TO;Tq zy!oC;Z2U2pEYcTANnr54-;qZb!s^WghO#~itT>qd;*40W43xpQR=C9%1lV0`B#0l8 z*XP&-n_{e5V}Fzoc(?hfEbMwfVK9t5`sO*oWS{(c5>l;6-oQTr!X!J@J|ZNZ-@w8+ za0XF$c-goU8hkmaU^UwdKZp2S7VD!z>)Rbod+U6!&K&yH7E~dXG*oB87_JH8FL=CysT)Lrl{@fuNf@h9UUv% z=+XSwgpR}jt;;pvr<@g!F*o-Y7lbUUG_3zIU+aL|xq{B9b@dZd+Q;zv1%7>8(A`N=J4E{Ffk=W1qjHA_C3 z&%W#86KjipEaziV)?}GH653^q9+{}5s32!!w|(T?`{4DJQ`)}(NJZEwL|4)$4X^jw zx@?rOXJS0(W6a&oeZIcJU*P26rv@Y=j2~oR!4SpWaFDz;tbNp3Tz#vaud}%8d2<+{ z6?IrCYaO=63}7GtxPT}ax~|W?XSZ>d{Ce#gxjQrQ%a&GJ81(D9IH}+jw(}v3VK0maSuzgLi2(Ys+RIVwTM5u`lX zZpT6G0Klhy6S^Q|Ka3C^Jv+a^yQ2kuY{qYps~(@i6%At|71WvQHL@Og98Ay-58x}G?GYg;SZpr zFXY^my%#l?b273QwSyO#-Zlj@D9A;9Iv{#Z!OvK0`mf-J()wn z*Bt(D)pxvbFOG4SY35#s@(J%BujwnFIH-yc#U{C}Qle;mHDT9in3=u7U-m70A1{8u z%LMDKX^n!W_mO^1>e@alzw*!4E3E}z5+`aJix|-b!ovNL{Ho z(#6?qK71rOw%YC&FFz3pki$!d0C z&W&N^E`GCLKg18X1cJxtdIM8~6a|(G3-w)-lPSiWE?5pFbJrq#gT1)P0D8t->0@Cd ze@D;#umF?b=>a)fzyf0mF+8Elfg$30Z=x{%sxJ5$m#|xQGLBUovseHdj{UcI1w9?ACfwodur*8D4^$YtW?$eUpFng$y?$FkM#w8pg&kSmo zvdbUPE_X&V-mp?RsSHI4RI_md;ni=3pR=j?ATn@h57LS2cERFH8+)TzfGZzR65=B# zZo}Vq_HMg~s*Lta09K&C5{stPl_ZuZuv&Q?Sp;Yl5zvK}xyQkDa=L9Dx?lT3h(drgmQ8#FCPI664u9ciioE z`(9VEsiB4<3Smjk!*mdW){DHWpXCLU!OG|r-lyfPXz`@P`fBlI=%`8fP<(v1T7HR- z0XYJ5{iD9N4WJ7>^a!PQ7ss1UJcKo?-@C`eNF!gR7v%uyRBaO9!s^jVO|Vsun)kvL z$4CpoN94pep@Zp*{l_^*Z~9+2)pJ6fyJT-4y0k5#RPHuo1thWg0rKEDZhB}93SxZ~ zpLQIAB77Xe@gVuINYxbT<>a=7H0DM6ZhoI8pa89k@mz1tK;n(9Aa>AVgzPBrfLs9r zuGaSU>P{pnD&qt=1;wrhTLwoe7+z>Mh{NRk8clK|FJwJBqq}X|*cV^lFJX*1P7CzJ z>)G#Drboro(A&?Wa*mxvHbNlw{vYPf@JgCg$AT^i5CWNl1oGd6Ig$POFm?9dzTG!9 z-Cda=-5bGRe%!g=0!`PTm(=XyxjdK@ee7+c0f5f87kAqJb$y0eZy!B` zUqq!yxU*&ElHnE$>(gurz=WTC$&}W}YK}?&>!730G3F*!ILrInfXn$kx21CqIowR5 zZ5!SlpDEJB8x!YR8|O4yn0+wC_+ZS8B9pGouDLGT_6gap?KyNX;%MyEQ*uoO@=@~< zK3dy(>yR`~gUhb>_GfdV)kDby*WL}J7?D%5j_<6ys5TGABYrVJ^}OO>Q!!>=qkr4->eNz%K86YdjH#5`&=ftwp@R){QX>R-*Mi z`d31H+my8dCusE>lSM(N3HKJ4Wk8k|WC34RAwfjC)F6LaJQTGnO71be* ze{V|H<+IA(eCL7PDK<={O$Wdh{&5pqXYJa^wsxhspRWo(?$?3zwg_O}MAY3cr?jJD zdLGQ8)=!ob1XveCPsQ*jMA>>YoU%UcU|)@!UcO87^^ zRa=cs-1m1b5sFXv-!uazGK%9eS!3&oEo5*0Hut3jquPlUqj_Hv;7{btv_+O``#3gd%Q&bs zzrW|+WbekGDW9rYsyp}=e0r0Sq1c@S#SIYOtMlkO49QxoUBSy|97fW7BWQWR(c}sN zwe#}{9Q7`Ecn28$b>Bw7U2Ac*sKR|sBhayIL)<-%^e%d%ncSDi97t9Ka6ex&8?LdG zO@iyy%D@q98=y;ZSZK^2F7_#2JoD z*Lmb1DY#N(-cMtUcGNt28|e8E`j#`>ob%E9j(}w4 zbR2YXz-F+3hOTb!p?9wb!Ryu+H}4>=AU7l}58o4TmRB1C?(p{_j;|{VG~d0=Z#_nG z4lKHIDg(} z$Z%zi9LB0Ru>(Seg+0A##~?(TAJz1%qF{LjtG>T} zPiyV$)q&-T1GV6wIkZW3Pz$4vZd5@9VXgR1GluRX8xghr_ik{Y4TX5y* zU0&VA!zsEPi1Kt8z@*Bq)4k&)W>d(Sw7OnNw(@%wEXNY=AX)AodiDoC0^KrNk%&{op6 zY)ES;{qg?jIfR=8PNNUH*6xJRjLyXxvlbPS3a7K6mUwyx!(w|lX!?chJ%8gPd{caA zE1rPYn552Z^Cjn zBkU%NOh`dKbl+|9fen7+BS@tgVnikc#nE*^)VNgk6(_>nen#OBdc@7cwv&6iDHl0O z>E^cuJ%$h=AuX=b{leu|J(dcNX#(dBOf(3;>f)hPv2Shu10MkfMr*bJ&-8vi4>Z}m zJVd*^cd|NqCTxyqP}IJUgu)t1$0TfQzCoUxN^ddjk@6vUD1h{B)zJaQlZy|Kfg6Xb zD$$|df8!$vAk(qndHDHo8*xfkTWwQ;y){_>urSQ7XSg{Bmk)vl-Ca-Gyr-RwM_o6g zfb}|L(V2wT3dygq6GHwp{k=hSOA|e5`S^{GVDG!0Frj0BM^-Bj^?`h&#k$AkwAH4P z@`&4FKn|I(M9*dPPL6>$k5bW=wu5fG?*-8&k9R^9W&;=Gw2@52V`*>GYm6_^^8+72 zikhTRgk^-VwzScSjN1T}E0%tBTu#S3E&Vq>g7wQku@U;1ZpjZcMochQ4qtpexj?2MDhKqBbvvc! zxph_JIljigwtC5?0?=w)Z4oK8&Rts>?@F)e;l5k%i~2G9nHhcl#z&~$8p#wcWczmQ z*nK{T2{cjsQhinFPT&g24W=eQz}?U;y%*X_V61j>OYkmA^zASV^p?F0xD&XXv8f)D zWkN><^oX_DZ+wK^AOF*o{pN_CG!%WQ?OA=XV1XrS8=OF0{4sN_FT6O<{sddR#Sh8! zZ@~S@31+-=n>@^@+R^5@r43$aIK@z8O^VCR=*h}fTC*Wy%H(c_% z^hMM{!QRvt1j|2Sq)ezO=~gPx7tXGv@P*w99DRW+r__KMxk zuxZAAbBZt!@mwYL4rEFCZ;%N(Y<&Kmh#P{&mx=kr6%z0K0%Y@}<^RA(xDekr#ws>K zEY-)oZr2NP2`T>h0s1c7a?CEJT*>B<7>X5!4fNlW2Ltar$7 zYb`5?jNB5I3^eo8U_^$(19;;{J_1oUpswncebLAQC>6>iyS?1--JzX!q>_v-u0h}q z9_%dS8buLCfq5V5HW_2Hv1a;v(3-5lJ*WE(TF{2~dHD42%J5fI`GJqXgulnuphd9r zGs{7yrVEEK#OCWT@yXaId?A*aFca(Qvu<&g9Dl@G#^IK-T9d!QKOv;I{O(6QQ2^hQ zJfhX3@LCcT$ZvcEjOJ&~WU+B6{Uxg^bndCO`&Y1VnH$UhyrbOI zs?~PvukW>39G$iqk$3HG}HES@-LjizXG5Tt&v#RAD0Qlh!&aKxH;-r6W^f22=<92$#ppG`b z2wO|Ky{+xS_gwd)NE=Qnig?}du0mOBd9NAM(CPtfYk@$N@bC;XFw3PF9|)n{cL=|A zVVpAdjK-^y4l=e-U)VbIwu&!cmdyT_M%p3ARaoOU?CKCjBaTaQbnHEx$a;>~cGv9B zEP@^AWo-gXbh>t!g3%9|BJzHdcfQy({PVX;jmqjq{CVXX5aDlUz2@7KiWsL}kXA?V z&BAaU7M3+WV88`T=@|`{H8pG2r@&n9VeinF_X~V=v2#2SUiXT1icGnIAhWr^+yMS4 z(y(SMX=w(K8zR`jyXZJSF zEZ@J#9I3F?<#QO@+YSHf`oyA4o<`(Z9<)-stB@Mm4~0ahWc5Ic+T|Y!r{S%&t35XQN_EWV*P(07-sWY#ttD@@x!O@{E+g?D9-u~D zd2zi7ITQX`s67LSg-v|!13DBUB9hpdtbLfQzw}cP7YmGT5usuDDPBK`Ic(-{N$3iF zkMYo(7I_{Eiq*+4?r%H-!tkrBe21n(Ng7&Y;a$C7(6oon`j|Ys8jYSQ`o*W-s(mpMNRG3l-^11nM#S2Q z8GTDpOo`g5)-k^!E7;o}jo1%_yu?0TOh*v=m>=4kD^Jhj@nDO*~+-OQm{PLS0{T0NIkotw8w?{0S; zQ1sv5LN-7HvDaRs+Cc$IS3CTAP&jVwGYKRF|2%=-Ud@nsby`r7it8A&B5m9QAbYIf zD+9RAG$#QOyy<_Xg+<5(M{VEwr8v~WFm5Xbh?d(Q+(ibBy*tB(_da^9?}J zhwq!u*UP-05OA0GJYE{OF#!8XTAj`ttM>*ohooM5`E1%7E(n-;OqOjr0@i0A9toH! z4X-x%$F|x4l}6F7L&3E^#K)m+X~QO?EBE}~lxOVgHwwvdO%U<^VVMf5SV!C{*Hb^zG|SwRo5o zbreZlKlrQLo}Ir2^nO6%?c3)Ae;(Stnb|G!Kf6M?B>VROSn{Xx1BX^;aeaPBdUhL3 z_1Ve+YhL-DaER#JZlzV@4O7F^~8~6HysecO6$@we;SVJ4_xIfNRt%sU8k&fA{l}`(KcR|Jv81Gb1`I89X0f$vz*N z1K2##7HFicI1#sTpkrULLUzh-k$gG2(7Qg4Un1+pqB7UOgA(K)P4QOUAoF$aQiELe zWnXC$;^WwTj4}E*(q4sMv9>MU$O;MnvKt`z`IZb;p)Ym+y(x3uqWYk-hgO535MGW* zbDsB|Ica<@A%SeuHjrlcVF3QWdT)LasDA98XCbHM!MNGTj&WS-LJ`)@2-J?-(6+?p zNzS-}}y_%c>QrIs_ry(+Fd5jikT<`)b zrPVQq=lZhk_|P!gyIsH{V-dRQae(WbIorN{FO%nN@B7KGW9MhB^QZtUel#>mO`;c@ z-ObN8k@WU%2Yt#Ua7)!+`qC77`u_D&%N(-S_oj^XN&p*;$)Rs{Qen+7N^)pJJ2_E> z(lDq&ws?{}(SR`y(f@$mUZ+wQ$L)5?!E`=6;-_WfKYx46RozAsQF7Gczd_Fj=8o}^ zrM-PpoIzQYK8cxitFIC(=#p|7cn|y_@4aaJ`I_%EJzx*-L-XpmJU+F7t;xY)7L9U1d&0_gCJ zbetz(UwMTv5zYRj0MOu`zrB;vQ}GXamdh_(pIDrgzLm%rN^&PuD73ss5XB@6WA}kc zc^|ivvN0C9=l8ftEoi0vb<)C+-&}@q^Eir-9#_bIYT!Y+s~LYRPJ2f;|1#cS$2ms% z?<&K%Hdo_#jT8Mu0Uq(qX^Kma^`ggKU*PVc`gCu$$;V%?FoXe!IznpaQc_5fp7nu% zXmz3jGj1G17K7E5so{6ifi3kXby@6-61rM^?f0T~An$EBBdRo~CY-i)`m=ni7FLQn zT#sDy^z8lG(UHaGl)fVmz z$$2{VcR!mqtrG(s)7c3K<)jSUA3I4xD=&n3_2d;W$AXq#tCudwB;7AJ)||-S-?B+H z3H&mIgl}hkoD4UjkwG28_t9zra{_dUa+d|IuJG-r%GKzF6dCugAjc z+Q;qKhBiA-m|Q&RZF+Y)`zbLRuM9xTtLxop%6q?O4T3vs$}p8KQ(O1gf8l|{q=~3E zIaRCRFNnJek<~%eCmy-o1G6 zNzop)tTRoAF86t*+Uyj&9+uB|rwzVBI27UIlUUgwXwxJz9cIbWVN06^Toz&1=FmEW z^m9H4b*U>4|F!F;(GqR9C`p|~=ZhNkfZCOvl=vIl2k=i1p*_jhVyvE1KVfHRsJ?E3 zGdA4{1juJ3qp}wb;7h+~csdOLeHk5v>g=FpWpx_pSrG7Y%QtJ{fp=ufz0N!KIi&A4e_p2quT?(f*NHQ|zcq>Xe&zPmbmmqZrN37?(Ihf#2PFO7q z*T~gdv^xU;@HGDK&h_>xtx;`4b-KQW@r?y`diQs-_|bvGTob?vH(-#Roa$&PeYePW zh@SFaUjt^v*ixLh)*Jj;VV_70Q?hpqDto=^^gN(K*ZaIK90pQbV(8{(jWdP%>g4|D z7y87xr>b%4dxIN|Ms?(NuQrzF#!HSzDriyXO;$Z9bk@Y42mY8#uz1X9QS?-4f9L_G zbD%1ZVQlpTpu-2wsx_Eoxbdp4=-o;;;&|EsF~{yb8msU)y(9iPQay|lBw_+xP(-GXz+uklZu z2lV9~z3w>-@*uaSKqKoejL;U|ch9pt)umgUl3;tr*Y^|$%YgokXJHM}SFOm+-^>Z+0 z31E$n6OAYx<|#aH-FbGcx!U4RDa+^ycR9Cjw2)K3nJ^{CH#6gF81q*x;CX3A$(@7b zG8*+aMChY&Ne)QxyJw#GAaNNt>YLv)^#nNDa9n+l|KYqm$ddk8auS4GLr`jWr7<@{u0pg!N^YYc_q&)z#&WuqtJ zSu;|+GkbjCkmSnMhbDQEB-bbHOce|R*Ro}ijC*XSi%H?aYl))S-O z6H|2JADa~9FLno>jxOtPm)(1i+a0fGF%w^8cVWIEp?JKbIkY-qQ2DO2!}s_Mc;0PY z`4ldo&HSvK@6uHI6hYZ`i+B@Z0~AKSc+H+KGqxt5$m1~skP~Z;JJ*WAxMZ$90fOx# zv?X!&;eH*`8@8ji)8hjIQKk;|->t1{%wkaD!B}P99$o1uw!!`Ubvl_N11?idNetG! ztg~c1ZV3h2dt_Y~7?e6U7*{XlN0A3f{a`FQ>2O+Yde~QXL)Y8eJ9q}i+h^brF{Ll~ z8Y##?Te!ZGUuzhdn2FFe*w6VX@b0<1&vr&;=lXOF1qfr<5+6+LIclwDvbORFnn0Ln zdc@@m15_MPwHy6DAMziIUuTf6T8=Jxi_5qBKf!Pt=p2At=}xtYGw(x*DzGo66TWMACn&F?fV zA2t641k17W)XAtr7>tSg5cpL&UR%nVK}!J$0b9oXkciBXJo8*gfCQHf}}=D{x@+u zx+r?$)T97%c8h`1`rtf)b=$r?yzsa^y>yHr*Iws1J*;yUA^KvxPG7aW0ramd>W}s{1^VNDSYHj6b?}E!tSQUfCvhzPlTUv(o5*PXO_{cw1Kis_ z*T+P#3M#Q)?$_B(%jK47vG44r=Y7V_rr%Xldv*Ds{vDF{v37>e-nIfu<{*YVmq{6m z1GTQ>yUKX47iX=w!Mj-v$9gtP;o<<8V?35`j1w01q)y{vCq%I>^Y-Vq*3(Al$^dF& z`Q;+w>$9Wzh>hNilH)UB@jB7i&OBtU_(pu#DU$y(>hCwwB9HBglOxd$!`o3euS3NF zR0*<>!o@gnej|^YkyF`M6~o`=0&Gv56g>39rtLea`zvg7co3(;#rW9ZjFkuY%hmW+ z+|Eg(W7Dcb5LuYj5}@I~jSxtDqtt0VL3ZnWErZ)iqHTp)$7i2^lh-HYLLwdA7T0Z&E**L`Loo~=EY3H0un2juF4yh02KA{6<59p*j4&3{2cPA*U0WrA6{tlVsJ^ib zcg0z7r%xN$BnK@V{kvIzoZikXuwW-lQ#ZYC(&l|cP86D+v*nQ-{Hsp)6!=gH@%DXJ zN$@z|zX=KhUS(&GaqgPOI9+pR`}4}zftwoVo%`YcnZCYa9!97q%JLMGOr8^mx0E9$ z+sI6@ZjSe;z3=Yrwr_pMQTWZ**n6Gp_x1~LN$>Xd9Cu8=;+(e`qB#piqPkDGRf`DmSlOtTGTO7*l>EXKD=p?; zEg29M{wAhPB2i#>qN-t1!1NC3z@tEqd>Un)SK2zGs)8+0vrleDe$3evb3Dyzqap1N)W9KES18 z9L!91I*nL4^M!pLG&2|xZA|1wMIZ!}uimp)+v~0_pBUUqX5yH3h6jt03*REDd43v4 z#eQ&dzIP|0MVYFeb{FbN+l$XunUFr*} zxn)!(V{Vt*Sv=3aqi2jO^I@~yBkgU%__s01Cjy}I^7h3*jLeXya)i8{Ox_T z_b>Zegmis(RIS`x?~&NdA=yPGZ1X}a+pm%R=I4LE70ghG%iLtg;8912Mk>&hO_=t2 zAI9MWexyNYSO{jmbIaMCk?KZ4^dYG)1KH}08=c?J!#gHMPRui$j289AH{0s)0UY<_ z+7Grt-MRC92GYr9y3VWbH`KVmG)g;{t#{Z;B?Q7*VX?v)vL>sUj}z}K)@7|v0`qmv zS-&Pe=4r9(P2Quevq-?<{w`s~(dX(`(OCU}Z%Vbl^_Yhcj2nADp8IE&KGXLJO~|8mPQVPKI$nWBc4&0`tYUYW#_qfBMx1ek z{gOO_e@Hn#2l2k081TiM@QAEJVLy9(nNYjGk@{rrOjt(l%rk4*)@puHgCToU0lQ@| zgbJbo%~#R2&X}h*<}OJ2pCL*CnzJAmW`#1d3v)95jm#}Fbf1}nchhX`odwKy%`P3Q2)6>$B6uUC<1QBy} zF)9WG>8?56bs7mk@YemtNfTc;(|`qr>&`~6WiLhoK*GL&*$Ef#+EE)Z*umRT!v}{x8SfWAtZJ^^xlJ*7MbZ;Px<@F5qRyUFBG;9 zy71DbNQJQ>x#MLiOUl{CW+vDXEZpV16W=uQZx1T=TZNEGKfU@ICbQpI{WaPs zzGFoj8tdpi_uB-GN56&u1R+GuQX5SKm95w0gIZ;SDZ=F9+};p4KgdvTbe@z)`AMC( zaHh({cCGxFqwU{#E}*l>eGYR+9?FeHJ1)`OxPLaWV2J?FX^v?cV`nImol+ici z*#g@u{1a2aO>AjgJ7It#dM3vY+8lYm2%?&&*~z zdEn)+zB|_7vEP$1XQ6QE{Mz`nFIUPVrH^wF0mH@6W8A%yQPD>Wb9}k#qvkZ7-}@hZ z*~bRwiBu<>B2lD@3V)jD{Ro3R?9|@M!#heu3n_<2tO%_ z;G2Ws%fR3d9|mALhEs2S?a*kWmW3Yk9^9YvspGOc6#o|+U8{PHaTBxUkB-udKN-i( zn&s^+AT!mj;-PU6&H!DNG~J);Ga&1x{K!WrXt$eC;3XxAzHpRJeU0OoJd#!ZkumLi zB-`E#U^p8~GB(KFOhut?jj#KCxQM>Jfu!)cUx9f%#XAx&Uu|z96o2m@{q|D;>QyX; zYy_Xo5m1B#CST{ZPgSXrZfBHz@Su&ntO$#~tFQ-9< znujn`QHBqG_{&zQUS_sgQ1F4wG7YwTA)q}c2iDR-dVNAFB*{gxevVt4T!R#f>;v-v zUy^N=@u_XT(1Pm>#^Heo^xgzbNn8*TbMgBNR$v_0jd|IdR*=}UIsd2l)Vx8fri8dj z$}C%)%31luVV9vKHRydJm>KJkS=0C{Gs+ZOOj%*5ev7j9o?&ppp9?7ksY^cvk9>o& zeqhq!(s}_#=wGj@qg`bOK%k4qIasZCyN(xw1a5p@<3u#~1-E3O_bs7MQ=ZKP5yw2HEDQl5=iegWC-nQiUco%yXz)JIT)R-FE%@yX*~XpKgTNW1Z8|Tw z=jMvB7ZH=W&Byf?eKKGS?2@qvl{OuwUuAnZ_dc$*LsroKT5QwCCL{h0DZB+n@jI8W z%n8OIef6>lHV?x=`xbQuLDr>5JSKy2X+f=5S?hV3?$0L}5Br#9_Y?Qaeo`T?zSvC( zMDQw_LK|l8S+l3HEys5iL~lJz-fizanmZjXc-v_kx+nK7KEcCUXyar&H?F6D)X zmGs;%ScltmAEaFE<1+4X(l7y0yz9kQ?{lbs^=q=HvDtxt3uDq_6^fPd-erCWP+8zc z64t@I_eVl2Zv0trBK}6|%dwcj@adsWw6rc!ZGmhrw32&?a#tU<3|<~PvR>KgvuVBo z_B%c(N_TO^&3I*1UjDsw4g6x4MsjNok$7R7@2O74gh0+CTq>FBtd=N|FL) z9((KblsE%}oW#e5q?kjJk(O=uYZCszwl+sYj*xS#MS+t9-1jilz8ud9J^b2rz7*Wk z<_w(9%5{NK!dKoW!bjR{^ZWnv%}^nco!aX-Q8q<+7^D!k+2v6?fVpq_8y{iqnW(Lm zfCF%=HToxj=EYC1`j7;rH1-1J-3tRXu>G@$`Fzq)&@NuLJ0^-*Xkv)1`(wbAL;^u zQ?$Qa)Bpbwpl9A4WXOkcSX1z;d+=!L_i*il4bQO%9A0~8oNkaP6-t1dCn(cg?`!>~ z^R&E9udM->Qq_qwwAMX6c(y0)eL-5GQ@-iz4}1jomrb5}R>*6rm7d)J6{K0K{=ohkbCJaGo%nYx0cnZ8%@2BcYos} zq&^yQH#s3?6!`>1+>UShqJkcuY9yrY`SuLJ=l6?qwZ84U!f5uM0af87qii5*0ioUe zer)^6{x0c61AvgcH(BWUhZX#Rk077OXmPr%!@;7OF^u?pCT30-m5}6TK#IdIowqcD z5bXxSx{A$QOkZdbCRpY+=<0(=D!Tq?oX+gpz`#@Q^WvgUUBQ0iBM`&s6=>8LO32wX zUp-SFo8L(w_HjdfHg%1G*qY=|?yjU<@%>OPBS;5g(nTju?ZkMNGIBa*Myt8y;l49$qTwxRcYw_1E};8M=Jn_fSG+^=Og$ittn08K0x zSKs`sR@?!C1j+uI1g!TcZOYA7zG6~XMs4N4@e!PBDkXasXw(+UTF9<=B^(ib&j;+Nq&Eu3xrH$Fno zm6sFNe9gy}FG45FA7%Rf_B*7(&-ZwqZ^Im(=^I)TGG`{ayS`X_yd7?n8tlRWSaNtzrzARYZ z9}a?>E)`JhFEpP>Z!Quk<+#4@*O8%amKp42rk06|a$?&w(cUNc`GJqnfIiYWCZsy6 zz7>}B#Rf)+RN~{ND?JCJy$tr?iH2a$`*E;TXUx55ocB_a+;mW;bg6?FiFrwzUjQTl zp#do_opi|Z17ZBYN1)`iU$*lZtHvv5i%L4ck^mUcu}4qn6DToBJX*&Wk7ssv(c3so z?x_%l{5^x)wbl;J%NIAN30=_fZj;*JInS9)0A0#{<0Hi003FO}^x#vT)A?aD7M5W~ z+bnVr@UI%MRU+tYzq*@MDdCtg*oLt0FV-d>vO1Qpeo*DDcTc;9l@{+2wTg36?}^a2 zf8!%O^(d+!p-Wbc9LHLLE9vJFA;}M*vL}u zcG=f%41=wW=p6*$Vx@*xJ0BU(vPIjoouDqccr8)gGK>CoyUJ)1&L8;*&mZAe#V{f{ zD{smt1INHi>yo_((U9F**n%6^K!ZT!B2c;sd^9FuHP@`WJNX-P?zQJ#+pFE7PJ5d+ zDh=9U zV>fq%wFrd!*=lOOMpGuIbO*I{^2J)vpymjPJkmQoI0nF{kKQ@Ua4|d}DZBLq{O~PI zVb=@*W)y@1BE!=I*LTV&-C{RrToGVS`+x(-4eRad46fSD>J60c!SOoCw?c%gW^ZHJ z{2~-Uv#a-6tsJn9tSPmg;*UL-kY}#wpV)(vYGGt8CiLF6o~71z-01l(G4;pL{*6Uo zl4HD%qvO)#1x-UQ?94_hs4AHe@VBtZNMc~yLwPnHm$r6RPLa>L_+6ZsvJ-)5Uy6Dg zwUq3=V=MKsFb1XNI1jv5|47l~-DY4C5PDNppIJ9qp`m`h_!d8Q*BgwMWe~R;3qF)T z*h;D82vpMpJon|A50?Pl+gl&ouC2@Djs-sZbv3uy9D(kV?(KUK}wJG zm)<^6B7Gwch6urW(N{DdY!BwX4WVh(t}$q}-wpAXK=X@BIjqh2MALFC6WI4)>>ZGF z+HL1!b>0TpLg1tG6b-$ueuQz}0E8vku77|WoM%1Sbf^f7>jRp~Jp~DDP4AnuPp4P9^e;^5lIGz#IF@1`J&y z(eEw4;g8;(6@gvHq);mTwi_?}50Z5!u@T)q;?!&>ztOY4@n|WE_%dpO4`pVN8Ql5l zQdu&AR4C#R5AIr#>=PQ1yFUQA`+a6K$uYyj~~qhf&L>|dF2@>?1Lg|+4L;cMQt z-9jr>`=J^!ysq+{7f`UV_pt!PHRkCtJ5=h@Hm%DeFZQ_HXKV;ndVysu8S6&XN+JbRTh~&x zl^t$c&)Ml-%`Z-U$EtT`%LON>pbiZn|&Z&X&$Ha-Nmyxn1>d$OQtWIXcS1Aret z1!H?FO7G>7Z-(#!>N5pWx$1E`v8-9=AZrMHXu>`=n#5Y;4m}glr%q%pk8slA_6Moe}@)&>cl8xz0c{qdXrC- zBs0-Zo;}{seW>LpH+0&Y%gE_hWe_k0b1tp+X5}(xz|Cw#0!xABcqkalSBGQ zs8J!E92C3)pkeTEinfU#5-5Z4IOT7C5j07KWWg7lp9F9Q-f$&H1F4o5WPjE9X4EL< zAROZzOQRkEcb_Vlp7ZhUdAJ*QV}eG#E9S(=>61O#wcXL}mX$erD6_Su(nXNjqa z-FWX+UmlqrzkC{HnwQD}0p#9Yj6Fd?@Q7&p87l&j=C{7W@A@pVWTktDKLy8neBeCN zJ5_H?`EX;KLJd8$KQf|y;SeXXQ$QJ@;HrHoj!qBu_%|GW-xI!NYjyLqMxqB*nQ< zN#kSzuwz6xvAlN@DTxOF@82=7*!C>N8_(TY}tP<4W}O z8LG{7U0|8F+&J-g=+$4hmO7%#3LdJ++4E1)7+*CnNFNL*sFgW7aYcy$lF|624xC+} zOIPQgy9Zey6l8Fk`IWENh-QyhruuFS1`zEv!lU~A6yDr(l7=iW(R|XQ7GGrh93a_B zHN10p?co%OL5nWpx!y>wys~J;N_U>6qsnub!PvUps=cV6K-qv@Ppj$?a+^{vsqhWhM zdeyXj`b1uMoC*IOoJ;Vpf48Z9bJkypw{iTDVSt`k6$a0?JKwC{Rt!j*_l*A9B4q?{ ze7t_%cU^OZg*nrRFU2_|aOb@;&CmmZ$R}g3v(Iaxu`{A^Q2o9UL7BXR!)5iTK3n64 z`EC(|nmi--B|P1{^nuJXXm$Ks6v}FE-d3`<>mnTtR}uz9>L=4Lm{ksRd#MgTAN2%k z?FMf@zJS?`IohC*H;*v#ZEYQ5`u>4J?&_U>q=MN2uP}GrPFJS6PV|ryP^jI`JG8(0 z-bJMTvR_I0#F3bfI)y8$2A$s78E=n!KmFMcbnZFw-Hrb)cY-89pJDhV-qZ=183$m< zSyA=p4Ss#)5QJ|HRvmr?4nEz4bS$uAu)!1kE@YvDU|@sAL`|(<5RkMx-$ z^1bhp=&vJ`ba(NyZFPF?QdQ`w{l;|RLmNX{Ej&n z^7uvrQ=UhXCkB=c-sXEpkXvoQhI-Y8g_7zX;L@=9bO+`9vhN@gD_m`6E6?`0=i9-XM;vMeMFYB8-?2NXdK*l8!^T>5WA`RGbq#xsQp5u z#~k!>Ux3QBStvLR44%VlU-p=NwazR@f($>ol}-2$HY*&eTOTA3X6mKNpz#o3u0TKX zJslk)szz>ZPxQK(U$gJss~{L$|8TQkcqX>>81(fbduKdZ;OTa~a-WS4P<`l~dC(K##FyJ?qb2$96+=dM%UU*40>8r17t~ z-+OmAR#8pAM8o>ZMp(L_jD=Eu>z7H}6<{VmSWLvv*Wn{Q}56y!24} zYg+6<(2Zlyu_;ak;Y-{kU13Z`!+R3S-tZk`*RXa^fiU*^fA5DY-f;<>m-_OFr5WUd79@A-z5OgfH# zeD^mE2AU22Y_$5q{aOVNkg;2yNgoqLtjsTX`ffrcW7>MZ(94&jqc)ls`urmffb16L zyb_@q?@3IT>3;d}Wtl#GlWO1qP*&>KHj84Wv_?;xtR3_q6`FFF!m;bM|u$I1M-{d(=CznznDg zVDNi6Df@jzhIWTB;VwDel)imeDs;i$*Wkr!Ys`rwe$)b-`4lQb>%6k*nI9oa$93Qa zvp}-iofx;BMgtItEj+2LuUm_`gr@zBkNh7AU1E(+fuX)#bz3eam;^7as<~~TwFqap zwAysMN~Rrvb z^KAWqKisc)7T#t1V|PqCI$eXh|2!iXfx5xae;C|v#8XgQdYgs;4K6VlqPT%+VsgZK z#Pz=06i5$xFYy-a?A~6i-L2MS)S>fZ1Yc6ia1`y(a9}_TUZ{_P@;L?mnen2Ttof-K zm;hF~T(11iyFbbzT&=UN?v3^agr|Qc=dKk8r}(m9Wuy0Uv5{!tqe_UF-u8@MMHdDO z^ec6da(6mr86#RWY0!W>z;84+)OtGns&BWP^hNn*`l5AAk^;Eq?LWc>pE57`_b)D- z2p&BdGUEP(I8CjN=iqBQG!@O6dZUj&>5J@&H;UZueF;m5i?5?L`KD#ps`ctR9Dp5G z3vgb+cFVe7|FnodKs^28Px!^Y(`gpG3C8x1myQ`HjjgI*Xno`L1*r{1XjzVHG(}BH}Wt-5R&(_eW-9Ysc#W>qAy> zfB%hdgwD)7T#zovw)*@iGEm49yN52QD>`@EHktpq&4L0n;u_Vq3hFe0TLxg4LRuBB zDZIz$Q_f)McJ_xl*^KrEln=?(*7%X>t6s>p&f!(zk$q19p0Imd8Qi42_Ha67;OH=-@;{qGnt7p z6yZFRl1S`C=xl}s@ox^#Djfx4*IF#Wgx>zT2kli)Q?rdU~JxO<0`sWZ!^;;M`G* z7Zh)w1de{)$>yi=zE%sz1l3rsV^2BAT&HEqx=Pgf9^#IcIiYvaSLMC7uoNtNEV^k( zjd`Ei%l47vt&l6UUHtyvjRqv;>ymzxc;muUi`FL$#&@Wn)(zlp53R;MJx#oSUC%v7 z;ke7V9{_zdk3H!e+~&L|Xi9RvJZ*F4vF(%ZDM$*7*KrDnWH-F^QQz7;4T?SQ5bCm0 zJNn=Tw+7rYLV$_FZU)1h1NRhQk7iINJ{$PkRhQ%QJ<~`@%sveJP&zYVp;5;2aQT&p zV4-@;>gv|{Z_47_*SGPq`oh#Vc&oC}O%^TqvKee&6=7|xyz~vlMR*7C#a{#pq1P8c z*+q|G%EmMQHFS@;+W9(jyqhS<^W??9$lc7`9efzhA53&AZpMG6>Veo4 z-^4=FYp>C!P042aplucXf~Y%t_j7~mAn)@Iw)1S6r4$vEiQ6~)%-aJXK|}GhQIvIu zI*VzrZ{-n-mqjiTxo^ZVz}u12h|C8rdMgACPk?@qg~#9i{5y)A1u#1dy=80JUr4Qpe8AS_081w?snV%@wGIAZ8` za7#`^`q+WLi}{4#@thMG%ZZpephCl48_iU?vzwxAiAjHoi-(ORWEc^ezZjHrNiN0a z8r8V(=I#_o3Z~R;tDS-c*uJVaCQj&u-|+Kj*LgI^8xQyzWC_-Dgl7rxS^JkxnT3pi z7X_K2^j8sbpSrYsEae7M=-y;41Uvw=KQ+`iA8noVkFuxM-oG*Uv0R4fZ9o2?$0azR z^OAtU5Lffa2d?)C^4;`KuB?|}TjT4)N@QTNTIjUaNxYM^JDyE}mT#3p+& z1j^jzEPK(CtTmEoYH}BCIx1^)P(i#Nq|F;1z%iMe3dVxUdC;GpTKYn*kXLo|Ah_1{ zf|(hc_{z#*lld~(S(0Xf=RKhOuXVuPrQCR^#GuGf8MiH^tcm2QAje^2R&mQ*SP~C$ znmlmvnH|UfAet8E(7J|ISSob?ZRQkv3oFKi4a8V5+~J*LpAlM#;wZ1y^HN zZja6^IuFJ&T0ax^)v=2eOr`e8IJfmR&H|^r9jZ4fKc;S{mpX}_G$G!`G>{X8s$3_A z44VZ_&#Ea-?$el7UURr6gu#iJWKA11LFM6sHeE!Wr|hxyFz`M`+j=;3X1`{xx^sh4$+*|%hCXU5Jx z&Iyehq4)rc;~12F3~1b16M{BKtEQSLMbv$uD3Iyr z%VGp~5CaBPe9ea%gyL%g>?R^>^Ijmpl!<`F-oOhw`__l)Lr{%1u7@T?zYplr=t~0eJl-i7D;Dg*hD}>))1;8b zm33dQ=ru_@59*O|EuB&)kgj|F6;rZnyU~AyL{G+l9O;(`Pl1C2&Mc9U`3}N`Cqram zh>By=xv{)W|H-q}1F$L=diHNx_lKglu;Ag{ftc`_t6`=m`+Yov~sGW4w>gw8OlMpb`h*8CwyhK>d3Ng zZ|VUpO^tZN_$4)fF1`DdXe8M2Z8aX8$rk?4>9@3p*%b#08|~Vn2n;b47Zi;S|3T<| z_z+f?gt9wdu`g(hswa55nO@)2oKj~f2ShN2Ii~>}j1223I#fzEHk!BZrNH2mUm5IL z0apgGa~fxLyb>16PeOPy>s}(-!pf9dE%!qxku}Cm&qB$n5q+0&rNj2VP~21^`nraY$qYenrR8Y zTtX8w9@EWUd;y6f(3+du$%WyAl_s(zTz7x$P z=Dljvl5y@%B0+2{fxI^}TDBDe_u%wRePN=G){Ww?3H>raTj|>)Y6M)pwxzQi^3#^aMHW9;Un<$BArxVM_(#boI z$sAsg-eNn_N*$Gx9A|Wb7}-u+s1M1)l_JbHjzeC4hmT5OwW}Gp(?LVjhmpph)!uKn zcGN}zyHEIVCaB;^W>Ylu8J&$pp_;@G_ zkyqU-+3eAjiXs#KMOrjpxyBL#5T&=8<8)O`Rho?1OQK9lX8@ZeH)UsdlxetvZu|n_ zc;@;QHvpJ!@P-SQlK`ghq@ck9h$yL?q$- zoknJ#Go9c4L9RXKT(>kQJueE~#9Yf-=^pMGo5x}Z2Y--!4yB!!m3=kDR~Utryz>q} zF=QpgoU+O+dkp8ZZG?c3UAigPtjeV77qe{K55K@zD2eeD|7-i;ft7As8`TF z%mZd5FSNO+c@m1IYQC**%G8;xI-Z={gohIoLL0BH)}E$Q87SjhHACPe(HjQ2pFoit}!|xvtW$>5W_TGPmi3laBgw(l^dm zEKa6>;O23*gTsWgW7C=$6ofNYVa?%BncFk>M~Cmvv}`isSe~?>i7yQtYWJHGPdn`z zg@VrxMU9m%9D6T*)znp^vu~W&*pTVr4VP3F{@<3pNhLIC5=_0? z-6JD=o^@w9t3HhX?#Ud8>mHY#*A|r@x~r-5oHilFS#!lO3(fzw&EacPmpMIeG@^Yq z{HIR(A>>wzi{RHBUdB#ADTrJGQaVQF8k?J0(%$#wVA!C&W@aKli-qigb!ZIlr!Zd{ z^yC>+&sdK6B9fjtwJao_@LgjU#==k%dO~A0G$%$>PU6eWrJ!T)4=S)jXD(K+)b_IG zDaQ8OD2Xzfa4ro3qan2>x@Cl0P9>RyzNcI;H%K?cX35f4cCk1n^L22_K`OI>PaR@* zhH1I!>s1hNtkK~lL>Vsuw+{xpcVS>g8x6kh`SOW zmo)G3pd~P1oPxR>X)E&atOvZ=Af#FLbu z-9LQ!I2)L!L*tgoPd8fJUJGT@K@EN6!zN{d8lB_J zn%ls_P#YVb?TR`%8%_p`4m%kTATwqk#z&yKa(bIs(;+_PF;f%*Af)W>w82Qc*zfpB zz7M0y({@1cgGR6;_*Ck6-CjfP3UP7$? z6m1#fI5UKU9446V9#Zkr63kjcHNW?rGW#+=Oh_!8xdM-&!fYMltq(P$B@L*u#+{*K zs)zRqn!%e#T)pPq7lXxgZgaZ!Zs#2Op-eLv->iDtVgp zlX6bfk6ajJ{7FLs%E7@LxD7;TF5!_r0W(rTCOD%Onsm!1W;-d9mtM`W?vhyEnwbHF zslL}Fm{gVEb+ofnBR4sjLmZX)&WazL0Mo?;F_D(?b(Jf(58%^Wildo2Fk?hP-&X_8 z-pWF-o7$+#d}VYOPCdXtRF=iok@){XqRvxQ;9WBDzcS{W79tA+-@ zc!==rUU$h|B(k{eV6>O@*fGr$n z;wXZp(CYHa=L7B)ZKCKG8@*djdgN#NAiu})Z+*eBz)Om zUeIZ#VZa!N-?#sa+=d3t9=B~pumdaeE}400jvN$#H_IrJm|bDGa#YoJm}91 z4zm_V*9TFsk!(Sz-ElM}6xD0cOsi>}*xBf0_2sSh>HAIs?I?qLZ*QIzl(*r>>0$84 zAxaQ6W!haJ*4fZ~CqzAN6#E01n+n{tb&rHfj%@_9Njz$7&tVPNW}L9*pwvQgH}54c z-n@C5ONNe3GUSHg`*(b+5Qb8oy=rYGqwI<>OskVphX)jfY9?d^v+3~!*wH{ChYGI(u>nVlK? zbBdXF5(K^1PHIo43Fq^fb(PXUom9>M2LZXJT2o4VgtYAlvR%pwEb&A?0~&bk6$@38 z;CY1IGJD&%-c0j*l#}NW-p?-m3^{~(<`!rVx5j(?`h)XeY}-^*Om@8~A#WhpRMS08 z31-WJ_Tu!lnJp(wdKjBFNp_f5pBrco?i@(XMdR{^QKClQuqNu6)|hQ@KY5CJB>;K7$d1ha$|*hpHSfkk0tmJ_G&O{dD~v297WhhD3=~ z6^D)yG9@-3yc<^xzY`3I#iTf5aoYLkVe)$KJ)r;3olN(tx9BIW?15&OkR)o!hKq8y zqQMv{&8enU`?!6WlV+-;0dfS;R#om=-Qz$dT8)tL-nfbz34_vvW!|dUpyCQ5vQCPy zNfn{c1!0^yxF4q7Lh+(BQ&EpHB5BA3i34dy*q1joP(7@xH8w7^lw zifP08Zc+;?4DGuldu)YmV zv~wfO(KF@4!`>~t8)ym5z0t~KL!PaR7QOL~!jOnBT?vhAtlE7vKV>oZ_As0fd$egJ zy;};(m1Qxbm?qGZHrA*q-Gj!J#n*_%jn|nzgtN*ixH$Lo?pgYv<(QQ*^t7581sdwsUNXGx6>$fS$M ztc(~?vk4=&AeV@feJ&m+gXC=q3ndoQd4c3p7GYnkk{6JJv}0~Ys)-jl7!ZmqwHrf0 zBdzOrRD(1*zy*$AJCsrl9f@g$Q+n#yAq@Z>HYcnL( z{ZMygIFBxpOr}$ew<10NrcATf7Ma&z+Dy2pmFbI$rrdwd{7@~Y#bLyV?e=Iou~Ua`tL83mM~lNc1dD^_jdU#G1o28?w{tt>rrVI4Lz~2oGoT!; z12qWLZ&V9GpVCtbb~=>CGsxiFT9nyR-9n-SGJ;mgBuh7QyMQ1zbYwK+N0PzCtPou2X|S zuLW>3;en?Pi2`7>N@b0;U{w~r^~%C=B65=)p5Zt?Q3!8s>(>@L%WjaY+U&gf(mV`f zG))i>$m*$UEBQcj*em?>vTg(=TG{Cwowmp960>iP4#iwuYJ*ybWPZg1y8+Oe~A4$92ylznL-Bt*`_yu51fGq0{TtywKtKKn|e;*nbu7aVRn zdcJX*AzwHPSfX)yA%QB%^2LhuF~&{bl4KQ^9hX5u+%w;Fkq4uqiZ6_ODU(+JLzA}7?lW4%8ZZR zo3bS)-hp-}De#>+SnJU4K1bNX1IYAfc4UItR^am<0mL^ZLgm^(bcmWLDv?O|aRdf(k=zG6S7qqi^Fw+${kAy&cr#wgHS>3CV` ztXz0`;l(15QM&7>y;lX=MoB-F;S9`k0z3;lS*2(hV%Q!Wq=Mam8PlX7>{ag|L@DgK zLiV8xlmQoUilIjU&9+0JLR(^KtmPKSfL3MVaIvq^Ubywho|Q~x54($^kg0v93Mjd$ zYJ?xydHIqD08?G{1kC6z!^77a8q%hDQ?2ZhBn@T(;XK&(mfCfAP;1T}lw+u%>&%&P z_0Bf9XsstsqaHUvM=3f0i#aMd49Tq!+UHCO>~JLS^NwuSs@xsv(0u~MwKjE6oos)_ z7q|B~ZEO}uIU|ltLZFUK`j%jVY3MRBNY5xyhA^;j-{{yzggQb$Fz0${gR9UR+j^vy zC)fpaD+Qigp`=zbRK!(55=1vIQV#G`j_is5Nh#hMsk$yUgaB$meM5PV@Ex1h*$XDL z=GJ>k$p21(mQyG6MoOPlY*9Z~BIRVt?|6`nx(3561qufoKPF@<)f@2$j>()!+6>;1 z8Gkazcld%Kdi8!$F~*YHBVNUMXH6RCgJ7|rkrc~pdnkQYrr<_RyGfaOKwQB5+OBac zBtXnNgMy3&3>|}@*DCa`qjtc;gsOx*A~pY&m-PlQ#9dP&g}-x^0-~WT=U`R{1=Cl) zxY5$=z75JlXAf1tp-zf7v`5-BWdNA!?$)kVJwW~*GsZ${PTB8mV;E?>MLX@}i{hKk zu=dDsVsWy`=v}G@Lf~@9YRPWnqUu#GwH?_iRTaB5I-&0{E-Z2q|4c$rq%j=brl9;= zcjYCGYNtaGRg@@)Nu4z7B{NFPV@^eC!r7CV@4~Ql#(Z=-LV3G^^vSVxuwkc$Z;QYq z@2n$&WuB>M6w_NWq32b}EZ_dXp%Z>cTWzMJXEN(Nsg@8l*0|~IR5mUF#)sMc`6va( z8@?@q6?Z;ja~jL!GK(**r}K53u{%2mI)s`*i!+%FKUU8}?(s@oR-1b@ru>~DPY`%R z3&Ii_HcFO>t8_QDCwHYBCiHtMCC+g+&36Z8H{IRmbiY?9^w_MO$&UIdaGs9-nAsI6ZQYim!mg=qK z*SzYyJIg=`;qz=M=fmh(qt9~Co4n$spUr4(Q>Ssz`s#OB+f90q5{7O*k`%f%_Q5J%@fc><Y^Myay#i(vap zi#%kfA{gW+&Mcm)Ms&ic>ys-<~*xsh(zpj`JRVaxi&8U35Y0<%P6L1cOlz z7~<_z5CJKztJ?UYc}shFVVsCv!L}l?F~W<0KH{yfU8nYa# zPf14{AE!0xrNP@ui%ju3N$|tc?_8Xj1XwRoVUNBvO^eVjW1e(d)T5QAESLLCR&tef z)M&~)on7)kUAW6vcbR$Wprp@%G>x`(~H|KPEouv3O ziZdr{K($RLc}}(i!x1H8p43Ux{Aitb6GY3Ce-V=@>?27VR_IU0q%NV|594H=g-VL7 zBqpQL&P7$-$?!A^VFwgrWAEr%dA^lhs}y8!V9HzXd28bI#iM0cpwlv}^S7dPT;Zz@ zI;Q=BX;Hf{MK~;P^6?+W({c7&`oOC>s;vstD$e3trcKct6H8nschy9athUs^u5ln^ z#Jj?7WMJ$}%Vns}RslZt?v<8?9!cs7ys06@q?pfsq@-FOrp?JO^u#L#^YB^)Fbx*( zp4mW~MIshXzNXTwYdl@|5uGK5>licl0Mrmy>Dsc6Rw4{o0bf4{!*-ZN6(dWR=<7HW zs7KenvZs~QN8bkA*s=7TMmqaYdF;TD=zs2P>?91kWxo8#;I^xWXkgo(>;#h@^VVaC zy{<-sm6n3dbw)#A;8KKtm$wW^&a_;q%LhQFpGUtX0xA$AiM~tr^dNh zrz15gYYQ!N?vh>zwsX@Eg0({g=I~87n<`{d-bFlKqTZY$l{a?6c95X0)iQ-GTwC9A_Q$lNmiSUl=?bN6Xt0k z?1YP9$k_y^8dNe;*8M=OqN3SA=G1c$$hlNoZ7-5Iw2B#*)f;XCo_)EnQHxkcK= z!~!EaYgz|UdN$p&#LSxm3Bidm+DVW-Morouh5~3d=MUp5#75^;6QaJp{X)S+?x2Ps zFk?@f4@WeG#(Yr~gHbvHuEEqa8-eaj{N<9Yv@)6a_KN^yO(t7s_*zJc8BF(0Gn-HD z+dq)C(9KdAR0}!)8dwwD+4q5WnCwr2w~ZqwFASoHktuc`FFNO~*H*7xX~D|4lgpjC zWPx4>t8Eu{>CM@eG75G73W9*;zWN7p6~+|u!T~h5P%siprM7yy13m1A`LxZ{(3vFG z^ddDRlS*$upE02)wTieo6%dik*PPg`*F6(+f=3j<@}xdrTk}b+qMFJbc>e&dLSP7i zbJKJ}1+S%WGHr);VK*S%i~-|bjimC*9q># zIOTRdWr3&~SyL&&tP$2K9dzM3XChha?2N5)WQH0Ku^q4UDV;I3*)#JBtxdYhO%9_R ztF%*dn;KzRcUurruzKH8AAy^kFtf|n*1%r%i?o`T2nzRoF|uSNgBkKFA}i`r4N3=@ zieP^zeX?v0lEA<#nkNZrs%D377zZ6ci6-CJjo+u^&c*t;tpZKloGg zs=1#SLE&&;T#Has-D|CZ_N+69dTNB}NNG@$%WLQYQ#cQ`gJ?C*YWK`>CkcB|rS9#A zKsj5S8RQdMu{0({jh5?a_3D;rtWOfWL#@UxsY<z=z>BEwI?Sj!HRf+e?`D zrX5i^bko!EYBfP^EtYpadvn&N-<}U?u!fter?&1`XTgpRn0YYx&B$aw7KZq{>H4C? zftLabWI5D20WRqpj<60@fj^M3Lro^F1@3c02GMN1Wg^|`m+nDK?`&6Lk@h~4cnJSmoM zu%jr;G2MV&ImFIla@}NGGe9R^%h-$krNiLRDZ)4jsaYjPNwUfxzRh!$gm&X_>f$keNM`S(-pmjKE}xcs$PW@ zLpCH+oYW6)Q501QTL-d`lTDzpR(QaZl_WU3awWdh8YY~X8bt{on;Gcp>v%68#z(;a za3fHo$%XNA{u5yGGXn{utHJ$KTW}EOAtXVVGtQl3tG5T8H>CdUUJa;pr+?wO0wy4! zzBvyX1Z(C=nS{w`J;oQF`=|d1+E8}jdCI0UF-ybbK9FfhT_vwJi^Yu5h!4`<3z^mr zkIpg@wYdxd8Zs=~1yJP_hos7g z!$iJ}vZ=0l{5~B&fIFi4xh+cusjbDf+n?lbA-QV|$*9+Pryg1%pb9O6i)b^bwqPwv zjyZIqSz#7sS#+6`;hn}NjEr4I&qQy8+6(ax^cQ|-Wj=tlfC(62>z*s`vl4WH*1Qd3 zlD!0}+szR%1_i-9a`RFcO4@|>?Ba1Xy7=g45KxIpkZqycf<)jQN-@c=;m*Ch)AfT< zL{5u$gvTz8(lyeCHA~#dV*au234Iv<@-@FpO>4y+uu5_`=Fpfm#avo~K2*Ik_KNhK zaJvyEHvWS-wb}7CM(v~T*-}&|jCM!8(>Xp%otsliwn3IRSJ*PCZOet3I!FMZ)!CY# zf}dy(s_J7@*vcqJt2_4qTY!z#_MxumFeW&y>>AW6J=IFG zGuw>dW-e-IO>UF0HX&gv2oRaMUuO?yE9~sLJ3dV2&u7ACQen%Cm66y@MOvY3$r6*> z>n?%a((SXQtkfr%>qCwY_iM;eC z>0*dKfYX#h3*}&XAA2s=ogNFgxd*aow3|V#Oi(iDoOgzIfdUM~iznnUvmE?nqF3h! zM~gmCo!C~HkclKqY5(i#$MH<(vWv_*Kal!D1581a0}c?)_e(%OzSfGeK#oZ8bWB?Ne-Ygv{WPS(bu)TPLZ3#`7o{mnir_K z9E#bU6HlJnCpG5IOvSu8^D#q6pne!v;ex{(;j1}Ifl=(c?hM3?_RAq`4`7Af3y_k$e3k-GUf{aB zmlQX?=@V`USzugUJDZl3d9*5RpIedxbt-kF5_?>wsNF%8F)JG8vZ}%DODVhHMHZCE z7COSpeNOCgrla!B8($A&kB8SuwK<6G@eQ_fa=u=H5hs8X~+(e5N*?HV^ZR-1NV*q?`2Nn1NjK!3sW_BGKV9m33ZNET>e7Q}EeR#2&)GOn4`nM)h7I*girpn zZ$A5-H*a6Pj{VQt`k{S4-u%I(lrZ8rkf0%yHBRWrtTO}gAezsGSq@n0IdE5u!jN>c zofT^;nhkerW0Z2l831qn27{t7TMy3{3zaWgl*)6$2!~zDV?D2)edp61FW>$Rd-H<} z=p_aUK@Uw$rGUflI1pT?-TXA;FqC!FdV6@*4yiO~l5Pn(HeN9m2=saQs5(f^XLhSf zKh?aY;d2^=x{@b*A8k&n&qSYn^UZqoc|7~}j-RYQU7y9XZ@jc0#k1f1(fa)3pT2ti z!+8Ddw?2Ed?Cq=9Uwq`JzJkxb^Eytvj+ZN*{T3hb&F8k_ljqOA^^2&-{~r^z1j+ ztC#!Jx1YXx`6fO4?vBsn<&Kx@(}(rasZHM}7)+#8!gfD71i+ToGG;6u`^;7s&&-*l z9%hr<8B>s~gLFN4-7~_1W^sOC!Db&p)~$LB3wb z0xT^olW>Oau3C&wymB^x9Cp`d}idNPtL zM^p)jL5VjX^d{4I^y+@ zH}%8MUw>17nGs zO;%NJ$#|>Dm+aWjYkhCU%VKiRf#M%*=@b5^NgiD@8a#80Dky3=A%kKEu4$iR=5 z+EYK~A1}4P`RYwPUTRN$$-cVOev_rvo~P%z{A{iL#utC^!7a93u%;DRAnM?@?n4%g z6a!Y(dB>D@1?X~NAe{ljB9KnO!0Mnw1$S!Cnc2-b8Hx!IS3xSLp6e1S6Q`rzsf~Z* z-C5PyR)4hEp89S6Xt90wmHqhb5A>(u_W7re7u{1|x_6#$^1MAyUwOVg{QSW!xxS+` z5jlf`_BxmI)Jhk}6*Y-}VAt-}`S$BE>t*rSNg#Mz%h8zxF1@+!1GTVij`PkbV?)u~ zNeg{^UCCG@X)t7>2{gmlkCxn1Z&w~IxnKVmU+u>$?WwQW*G|0;E3MS$z5Q&hee26V z`QTO?aX+B56(h|h)tvJH`KIW2=aOxvxj;ZoQbeszW?gX88AG$U%|Sg5D=7*m+GH7& zQeW9=U?qV6-4;S=NQg)7>jS=3>E+RCd+LM2qt*7CZ~yf3c(Y!A`uW?(i|(l}+&hoA z`g}Z>uRPu!e*SP4+_PVQ`({1+mVf&4_xV4*{r1h9c>R-j{p`CBfAsLvC*OG3Q`x+3bXdfnrSZTjQVyikNgxMi-}z7O8G?rYf3XJd-G^c`wHXU>WmP^7gTIEv@f~ zhlvTy<>x`ib}jd0NYGn9T9!{;Y5KAh_?zpqS3ln8Gkg7IG4StyC6`1u!Ht(RyEG`IH+;wpmxPHi@wqHDBLP>Sch(UHZS z3&>>=32b$+2NA;ydD7Cf!fgs%kzH`*EDn&J>6>0L7$XW#q{n=Yfq)T2LK`ps`;R{P zwO{(_S`$yF)lw6%xW@wDCI&3o_1wv=+(k3x^6fFiDw@?uMtXHGX+FeDgk?zdZQd#q#)!{lpjUor6!& z=lQFf(BJst4}S55Kci0OtWqaJw0tg4hnU>O`3@n!K-|DjLN>9+JOk6-!ZlG%RBgb+ z)*d?{Mby<=-K!)VIlDG;^6cAcm3mUiBw>3)$x-%*^WuN_6)gM>y&++gQz_EzM45B# zGa8K0!&o?yAW=aD(+(Xhr5)_#k(_xB19ArjA0z;TzLs-yyK=e?Dfrf5fHP5XLH!4y zx9b>VKVJAx{c!pDuYuqG@-^^qOFTY`J@IAy>TU4552dD(O2t9*)tlkFU;E<^XXo<8 zVjS&A5HX1+8*h|cPeLMBFJ~>>N`x<9%n_mZZz-WV6u zM0vC*EV?*U!d;f@6$G^#Oj`_rMSHa5p1QsFXvzJCeLr5leP^*f^+kK99KhZ-r>`ux zZ+-bEzxZqa$-B@0Bb_y^yaaQac;-s=ni>nID>EcASEANL8Z z|8xuM7_l3BD8VV}S8)XCr``t?aYI`|QGOV`Y{XNfo1!{9cYFuGfD-pBGojyL11{jF#^kHb z_2jB33qJ4qBxnkt_<3Ssg^UC`6Lm|q~b~N)<>^7@kkDUDMt^8dIsKM zX{1*BmNh2W7)_5J@K615-g~n9=IgNa_Sx_3FDh|=`$32G?#YOivww8)&^6>L2XRp_B(t_I(er(q1xgF**xwgYh!bK6rfpv z4+0stE91P?LfMf3>6yK@aUS;(pE?QiXl;D^r+fvUy<4_?>dW>{{YIaE{mA+oU;M!@ zzLBHhx;>Z|hJCr)7>f^&KGZEKxUBE|MAi`OgX zq@2JUUD`$h<}|nFc`x2-zHKeUy8hyCeRKsM9050AI>g3u!=F_;?#o%qMw<@f%OIO4 z)(peVRJ#~D(IHmKEF)H)%$Ky(E!cA#`iC4cGHi(wlEMJi7{=ia!>o1)3@`qV8)hts z2Vl%3v0>(=3wWtBX95vER!_dhpo>#upMI)WIE~XnkGl|&N!4~~-WhTB+x=mQc4ex+ zz+qDBA$ej}m}8`-?z%TbwHN>AM|ZXi^7_W&7%rzeLv3YQS-F=nc7|SvW{2@d>OYs` z)Gl?+bT}h;*LA#!R}4Lx_tGisc1K9>iWz!J*m@ot z-NT`ht}Oy~EaU%x2}-QCbJo<5hzv$?AjwwAB{6qaR-V^6b$z)BmS-CrpMsf&t}=L; zV25FA0p?Xol^6fg_b!t2Vn%^`R->-562s@MI%Eq$*a0h~j&KvH4E6;qqUyzw*6LzW4r3?NgUY|DslH-`yKcd@K!8ZVK6Xox`KQ#ZD%+H@*vJ)?jQDYfx)V z8&f?58KtXbiF#z@iJCQ%^jVqcSbc2IZDncI3f&KYs=6p&-0xS8ferj}Z}i(QzAVk= z@;u$$Zr;hUI$@Q(ZkVrM!TDUYumQq?K zK?GU!bg6R|#f9gZ4nfHWqwh4#-i&WD`i>t19EEHgFirmAMq-}$!hLnO{x5uPZ`Th# z`Pqm4t1mzQ(LW-8?WSV>;V;+BKXe!Ir!W8U_3B5T+uPs&*KdgPUUH@JQ+3dQ6h)JtJHZd3WJx7MSU6Fh#F-M(F|FOtA8MwW%BcfvogO-w@wEjaj~a(NkAtYEtM{wE^mjfv^Ct1Yi7e_ zE}_LK0rMIhrR1|`IcG&e)K+KVXalg_{XkbybBlIiBBP_+k|yZn+~b|S;ZqmuA9u7~ z+RIm;z8i3T;*0j4#g?Cc{V|w-@$}X&^D+44h5T(Edk_CNFZf@(YjAl{ObAvJFhrlt zBqubkl#VObPUdP7sDlj`j(`X?ngU6#6m(4|`z zT};ON5J!8sQaM0o8K^0_^fpJ8!>{M5g;&T&XM?`h?W?@_S2^-0Y{YruD9+uAMhTRJ z6J^ioi)u>W4EM}jH-qadPq06UktW>N`U6o2aAyjSWvAS9wMs~WvsI1zOt z>-=P=mtrsewOe?g=1!zuvhLzXw1!pcCJT#cTk5T&?y431LICTZO z)akP@j_0AMGO~(X{^@Ntqm)_&(Hw4>a?rY9A%;*gA$rme&ECD|f!fAk%U4CSbw$tn z#lOL)7`5PINfr3@pl%cE(nUJuL1!=u-F>Pjac|pzEXaGNM5?JX%oWJL)bQUFJuIw7 z+M$n8Vu1*$0HacBdoc<|mpv=wX+-KT{!Knb&(~kdZB~3R`8cZ~amHt!I#$;)(k0l= zRZ}dNW+T%-vBl>z<^d-L7(4iZBEcW2E*Vr!ZA^AqJ7wZrs>z1tF%Vn8z|{WY-}>IQ z5D15C*R*kWEg#5H7_M};b&8ZkF=?*kGZ$k;NTz$(da}m82uxDSF*c4iU(#icHMe?d zNBX2a-9Tt!Uj+IxQa}xgbi`JA@gFf=8=f72Isj*D`@rzHTskVboHG!(ICKDTK##wY z;>eBEC-2PI1o)8xskOj#MudK{GjQ4zUO%f4L1!5lnFk z;j4bUpQ$*qPQC&UY6X(g>^YA)Ui>?J3Xw((Z(J1wjC#Nx+p0F#f~h7QR>QnZFg7=R zB;R{uHyI(p*RTV*4PYUy2REENZKi_-FPpT2j?awoWipZo*A?9DXb)upA_45V>up9-6otzq2_Y^(1H zBM`Dp0!ZlFMpDdT@=&j~dc34Ay@wl{LdwOxAG7JBNG{B<;27HI9o(xg%Xu?tC-HbQ z{luA*N1N&2`rKZ>{nIbbzmGvFPkiOx*}ISk>tCIS{o)UP@x9AaA94O-oVebt$Bw${ zXd41f<3-vNQIn){+~@r`<6&5VDFp_%a`L`9#Am^R2N%1#0}U+I*xc4GWF{v1HUoIt zwZPBnt@3CdP~|}iU=ZHt%X;ix9xv_*>(9RV-iZAN(Bt@fr{%H|_F?sF*V1m4{@huu zl%_Gf5m;JY{M6K|@1T*^D8FWzF!Z%=9{;skr43mHd}OR#_?;VLDEqKr_c%7lxr}tQ zi=U;eS$ouSQTA>Bf6L|nqb--8A3gf>c1FG)M~c;V7^K~j&Y88KCr`tAWQ#M`rbT_$ zAyHDRPnn3CwWxbLeXvuiCtBPJEZaMFw}!U018htkwQ12#AG@v9%iL2&U|CqJj>nIS zr;drff8+3K{V?9?aXj^vd#4napXaaDeII`QCFGG5rFiqwd>1C?w}1<@-8)#s&LrMm z(Qv0h53V(BU2~_Jq~<&_gQiF79NErmHlMgNzeotDkDkR-&vw*O6d8HTrWwIEt*D+) z*ks_48ko-~I8+c=?l$KYtx>-n|E& z`YOJ250vNnJb&dLc=-8OQI2L`ND(8*7MCUFj8pHkcCX9zLTB!yRE!SUQr$&x}N&uyg#yim(Tk) z)o`V;uQ212=0M$N0o;{GK6lPFxDIP<)f z-N($~?U1U=vz1wWm|BNLJRy_UJ=AaayGB0nK6&#rM8mnY6a_7}?ZbQO9s0#nf1LMz zm*0BWR=oF!MEbi)UDftMbG{=d-_F-&+Uo2^L$_>QS`=e=ZM$A@HCX}VD_5{ig|n}z zGTV^7mc)H#NEPXV`a_D;rjdI|7fsq|m*n~A+kEO^-eYpk6Mvk?0sNnLPo|XZfV)rB zsw^S!q2X8|Zb!c0*r=#J>#7xV5Y3uAnAPH-(`FMBnTWQ}$T7wdxwXbjIyZTliroxt z<^vF5onp5LPFeJCe~Z6WK*N6gdOgqm;ro2zh~qmXq^JEjkG{{p!+qKL1~6!>!p^`7 zAHD9>YwwlV5Io@f$y(XgS1Pq21URG-&}UDT$TRkXLf#Y~uyhlq9?4^P8_DaDk|j!S zQ8o4ox)cl&TsJ$`R8b>M(h7$C0`j~s4g^JFuQ3E3e*WMVol+oy-a!$rajGO!zHCm~?bD1Wb~{7%=4vb*F^HeE zJS!d8>%863G;wW*9C0bu)8*ExZp)go$4GOok_aN?oaO+%D_Zwss{T{YIsN=I@9+Nb zCm-9JH}Ur4AK1(No@unFzLM{OXzABh;KR?qgxXJHcxU!*rQs59+I>`FNq&y&wsU&c zlF*XZQPXhE3vH|s;5i5&Q_*F%TBnU$+a4F#X*%}Wy?C!H#_4;`kj(%mVjC<_h0F5d zKll~Yeo#(&0s)1JVsdK>cC(eNk|*{6YFl#hA;WFgGV0henho2;Ms`$)sWdNVL>>|u zUdf3)kW^-GP7Si>T-bE!I&=A?5VQ7>cUmM*JlFMj1oO*m|2rwKC%$a&dDqL=IEN2E z|2Y@^v+ulm^M~7B|Mb(B?=JtPO?DZoh_wt!Zd;>lo9Xb*s5_(Vki~{;o+u$i6FSFS zrzFj8Y8FH(_?bsHX`od z;&{pQOg-B-5uY={DaA0;*vcdnjX5~gK}6J5^^7H)H(NccmeP4Mu49N$WO>gvAyr#i zYO&I^Gy%5316k+sRKrte*&fr2ZtU^p+uJ*NCoJ&9m+n0^|F6Rn^DhIQ_$$bIFR@B; znRfiBpvR);uFX5g(aEN3kG=G)*1Iy1pPMrJA(dW0IYD@TQ~NXP)#~mD32jZ;d=Z7T zGgTwk%;ZV#d!wzcn_<;4qVZBF7?t2f<+gCq+z2f7~?e&{?HylrW0pEkrPG5WW zKK%T_ExcVO{oK7=O{!(imy=_pq*InTY$&os9HY72+)o=)WvoT#7H9C3xs?<723yvf z;1>3Z3?g@tNylDeBl+rh()_>@kwNYDoe8cdPDZ}7@cx9p&YO>4+uQi~vrm8Y>AM}C zC%%C1;kDJTb$A|r{uOn2#7_ng2Cgn!f>+lgz|mwfViOr3n{kMsVnz!!_?J=I6d zchvC9kUF+a((JM8@)mVOqOg^r3e|lq<1+Qrlb{0CsSKU;lEq4GGMCM$OO|g>R+@U# zLQ^nj&(?BM=C&p%;u>TEPdeTnbp@U}5&U?{?TJ6m<0|sc{~nJ0LN1~wtvttYFZz<$(0Tq}_TIGD^5i)41I8oH zh@)lHk^sT*Ld);~eo-}%8Icj0geBOY!tX8+85u#A)ZJCCt|rBSK85#v-}imr;AOn; zyZvR1=T!Al=Uh^vSD?l)xJQ`PsLnqd>Xnk6B~U-FI<*`dQ9C2 zJfAk#E?#9d9b%k$xp2(IrZK z4P0@>pp{0}H!77OeJ>^a`Y`=z7Bi%Y#>YqT5gs|kP=2*dy@i-`-T`!bUr1!$6liho z-D^9j&M@HLpbGB$b{;*cToPk$cQ>3gmgE_*fDbCUNMqEXA|HrY-`!0$Rh-+wjP2W- z9$UEE<;+t!L=l3Jmy!3PBlx8o^V!7YyF|14635y7ETpNfiwb;s-`CoOJNr|<2B|-{ zpCMb5)y)MOUPHkdA$M)MLpC?Wv%s5Pu+nNDvp4XdwW0M0sgUnoxyvfjD~M{RX*BAB z9&+bDZs)#vnlk^YqbV{q5fN3gdx`ZTF`X?qpQP}!h1ng)8sf`2(*52ID)B)GoW(;cs4BGNTIV%ip-}|wo;4r- zjtdV0HRjb+n{iXx$$`3E<>{46w;e!?0@=w(VP;wIb&@XyldP#5ttPEtybGnRHnDiY z;d7#e?*=dKQNv6fag19->eO6EF>fFK&I^4&vCfa(bnOr6h&)!y54cY&OCv>k?! z1_nqNq9+I(%EmE7KDFZ7jq0^wW5J>X)$QoEs1vM&YSVf3RSZgsUm~S80L%xo$$#^d+Th+a3T4_Rkw6zxB}OcmD7X zzw^-6oBw-br1++?^#8fCl&Nm`NSe>KeYFKZIr!v(x4dvN#odl`!`so9m&-Vpiy}2l zMPVN8(CW5$!9#(2rVgWQ+i|2;lndr^m2nBzL(K#LOFezORaxSv^QZPs{K6xd6hA4i z;wO}%-gZsILS|P#t)zq*vl#u%fc6;7 znzYj0s*>k6BA5p2AlPAbEVd`HZ>fTK@wMwsfR;_v+er2FHNocMndXyLE^{KvA^pJaec^ItQ)!M$yaLSStHoG&_y~Hl z4LnDU))ROh=aAR~qHT`4;Ehj2t%tw=avdi+4R2u}I?>Oe?!(1m2&06Dhcl>Xt);#3 zC0KmmE)G5I*h~YyW(wW_bXDe#WJ=K(2`qDjRGZ-9=d||TfiCS8u8vJVoYf4BS;5Za( zs}8`{0VmCKVb~CUVBiA2`olkncOlIoh#|SOMY0tkcZsb}oL#L$Il*h%ZUf7_8su>Z zGh!>sjp+E*D)(rMVXh+%Ic=(v#)wLv{XjQ2hv`)D|?4WHe{Z#1f#A-dkySmS`x6yx}%6a*U64DU0~;yPNkG5`*a znnyyTRpdcsar$n1)x$sh!FRv??t{@aL5f4cgDWbL!O8vL3hOL&79pcbOeS*!OKOa8 zDuEbWz!#b|*C9~1``+C)w-aZe`4op%24GFc7!`P#jJkkTr}DFCkbF%X!Z)et_Z_vH zIOz7JaFH*?LBI9#J4i_9jNyed`Z|F4QOse!+B_yl4-S$&AgBe1Ju5q-igy(3gh(Mi zgyxa$Q-o_wtAg!Dr!!=kdvHf3(|k+^c4H3*UI}0Sp=<_+Z=CfyfB&Xz*?iAU71P*kuK@Bixh12)l38 zgTO-OL#j#2>JH}F5U|hssuUA2nogJCS(nyUpZ4&NU3Q7GfP$;K2WU1>sslJ025Lu0 zcrKDDm(Zw_0izVwA>~@VW~)9dE0JRkQbwz=eS%T10tUDrwYmCG*i0^D$DX1U?JTX1 zPvjr};B}j>Ya7ve9X((kfa9nzeNttv*%ofx;1V`S1PFJAWfcT9z#2BUrMZ{P77MPX zk(UsRDHkUqck<>Eq-#Yh2%r@QM$pH`+Vb#E{1hwWZ~v9I*(vAAYbVnal|NoG%Wr?@ zCwvos`OzQy`}`G;eV-4Xef;Sk{PEw*U;X31$4~QC{;J2m%@3b_e4hXClRx&G`R=#> zD6sq&Yw9ID=JgkExbnEGwZsQqixHIG3N)SWM*|!CI98(p-A?6`2RdU&ALP~suA%{D z=28s+19=`A7wits8@sQ0M&_KrG@QAV+d$4s2aQ*lmG^a}<=!sN>#Olc&px_ok>7jB z9&M4+Rg3(6QjWeE#&5-k&%OvWfHM9ZD7*!g;&C>6_mi{j22pKaI()<5a}G_GMLDdu zvfy=N^H z*5So>+C)OM1&IrH;`jvfIo478;3;*W@eAI$S8*f zX|_1I(8pET>~SrybH&n#c@#Rwr4@^0AM3x7$W#UGa(tyt;&!_ zxdaiNb+#9e9xZ3^$T39HQEhHXKKGb9*C}*o#%|juBkFUEaSC?kYLLQ2_o|0~`h)L& z>z!jB_Gkbf?+zUeIU5;wsSjALO-2`7|Iqxe#ZEMjN1N*`9q6)EvDBEk#stw3qds#oIkca7 zL`|I7ao9*6Fk1JyLT5ER>8zf1=EFa8dHTl=q`M6{c>)gb%SSqdX~6vCKVWzFT!@tsxX}(nX7=#UUNjos z6>vRW)#lk<6FMj#5tHCJA4~ReYc;nw86fKIX1-+=()K{sbY|&&dr31c)3$O75YPS4 zzNGGG?OhELBG%q>fOu_!y8X0)6}F!?PRj{* z7$?qdeMDoF#>a-Whg(5@a0q#zuk*S4T-w<-YFKAYS>6;0f^_&|gI|5p!$1E4I!f;t zv2mv0QbbJ@X1^i8qr)wK!LnqhHBqc@Cq|wD^0T%hR^t#Drq((DLd=_v9#kjk$RdqYUI}h8>=MapI_e}F0 z=z2*{x{MP0ntPVCcKpy9?B4mv;kI15%!wz0hPU2U0|Uw!Jy;MUz!;ltPq0oE{a0=K zYycrH!Z19{m(oKKQKuv4;a|AKqO<{fQ0`!C#|aI^EE7DaLRpTmD%I0-gGRj?>`wh0 zVn#h-UJ7RrhAcsX)c_6x-5__~EVyfFcae){PeKN&8@fE;k@V*C;a_|m+7ld{-sMD2y}tb7Dk@XhSA<;kAo(co{q`qQ+w%Nng@t>UX7sb^p4OC zIb$U2@zzU|`fI4DEtNfHtHJ7g$-&rIR#i{7gjQ*2g$!vA|MFL`4B;%Qbm$yE@EM4< zAw8TrS|G|zdcc_4XHH!@^2Amqs-W^thF=?`ar76tbF&65RY~)NOc}65pL=2DmPW{f zAIq%zIksxupib^B3j9o%^vlm*98AOhnXSLE^GXGa0+_#0ksA$AP66 zr$%_`IS1PPNh4Ss%3mLowQDCgEsg7Wckgceb)M?;{d*a&fLMF>y_<{py~plm&dJmE z7IEVB*YDk&!?D!Jfq9RPypT)5{`58)GDY^LJ*Q1AOAPBA$Y5D9+`XaS+7dMnNWXh+ zGHM6Q)HY0*csYKo#qMQbFZ6BHd1sDZoI@pWp# znT1=_Y7OUV?+#LDxn4f?E;*4?zBH`oj1|`slzY1$KHFBm<yqU(LFondOA0-msZbmuNOnE82yLhnfJgOwh3{*|u+9%-wEp&V3&>W(hK zFIE9QzaW~sANOIkoO)k4i31?0Dcep}j;NZkC7keS1rbH53htMU9SaA~aj7;1BG6n| zW(`5$7<91LfjM^;`CKovC+pLjTkV~P>=9n?+etb4E|PM-f>WgHIf`tHd0bJ~b_BR| zn(D2MgpO&gn5-}k%t^x{vWN{OI>=0PKt2TqkMSCyyJZIYp3}r0b^ROjD ze5R?RU$f5ct=PNPl|KJI-q-b9yYracG!CF3ZC|>qeCy2%@7-*pi%3>8=_rJ68x}%N zz{NPphYpfzwV-#4OTJI+iENQEQ){In6kv%eQTJk}B6D92rulZzTJ_VwpKBI&)(M8@ zcad$I^NefD*u9mR*Ru@({F{~S-edNNdw{M0%}bcv5PXS*4zN< z6?dFch-gz1*u%|6KS&|odmlBFK*d=PdS)><#qQbh`c@6*_1Ev+OoK6K^i$c_?yhnmNTP zL>?tUwh@{{updnkFc)MWM(bl#HMV5~Y{bxh#wgY~501b)y-P<>9_+iQ|3miBPhPjZ z?yYnE@d*pRcB5Ck(c|2CD1RQ(2ExyhrMZ$+<7#AF7xy^ujlFOq4??pYx?j!h0NsxH!KXb zl;o(*rEtJ13`HFyZ!TxIwxP^Hi9xw^c@DfTP<8i+04JdXYXB_(pSmPf*bb;g*AVK0 z6|dDnjKvLj=iXBJpAcAct+>7othw(<{#<712hTtGoy!3H92e6iQ7qms4YE$w&X{d? zs?+)qtuqH6U9ITEhVYXTfSNQ+0t{}}Nex$z=9NRaZ_}9@SH2~4;I+AXX&gZXorrN41COMgB~sVi_Ox)gFs6tSe#8`HGT zvIO@9nyuA=XTBQhW5xyn>w$h~#bM~_Tku-6U>R5iNwDd5K=d41%dBX)UrOR0&|;ys z+}z5q@7wow+Wh!=`oXPZ0AP>KFtV#INiHdYh8dS zJ9%y5yth*RS~Yk{Mg0A|X=C4e*d9?0zO9(x_fs)}D76z6HM%0xtX2+o=_O-sIgs#A zT1x7>WkbBq%5(ZYh&Mr6Dx-AVXSPB{+aT%FYcMM~qrCiRZSA&gj2WRv&<{Ztm}V!{ z>&)*vOS7-0+pm^?^6JUSeDNgzmQVeLqI>VrdvwMS>lkKUvG zKf3Dwy%RpikPY?ma@m2Z#Mo00$ozSB3mh(bt=(mo7H!r}NCaq2`_xcm9L>cY9zd<3 z+XfJkC-#ZC#_I#mT4NM`>vk45gvkepR8&0d;a~kqDB^TZSuX?^&>~yQ!#fgWq)($U ze9>+@v-QDYc}aFE0&D7E!4VHzYF5g_ zzxFO?{BM67L-6GFNBU=<{&@g0zIf#`RKeU+g^9ox>YyRd-sNcD2@`fLI?=gGy&egB(T<@V^z31u9NXDD3P+`d+#4C?nesa?}9ei{G4E+pQOns&0 z9&1}Q>Z60l+yx0|*?|i_DGh}Cl^t7f*{&F<`&ehDdGZj0d({?H5!a2RJA3V}=GwPD z{rJVR+pz0<589(bO1ctKzK8d#B>^mV7hH>Fdi0vPvO)C%8B8d$E2cE>A*DJe2$K=W zK5b@@lXl)Hia^8=t%fYAQI1TZFerW|PN&ly+j7a8MrZ8dk`a1+zq)rq#pCXXU-`@( z@#NE2&py0a=3nPB$Jamm#(!_`%GbpZg0Z&4sl-${2ik z5>If22s#zm6-pM>giV1V`j8NWprFi=T40|yj)jnd&LnP7gGhm1Zz8qZAS|k9?n)3# ziV)E;9G9SjD2J(PgW7ob*I(ztES(8C`^xk_4Iv(`75f~JO(x|0%r)m}Fwu!K35*>m zUH}Zn7|W@-yJLx_5lWF;AXf~k?i-OkWQO?oImblJj4m3$#W^1SjmP;m??FhzH<=ON z1Xg|%EAZu5fv+a8(yXtm0mupsTg+ZGH=mtj?s+h|dWx^Pgmc!E*^?42DjV3fc&YhXN9$CzsSq`yvtwA{O$&jG zdg;D{33R5Iv<>T^uE^ZGbkFnoNBd{+(S8wN{msGsn}ho|2lxNq9^9wTq-HfPL0JLN z#5@I3Yd``{9m#qT@KTSMQC-9LR-7P58vzC$M2n0OwrC5} z-Dk;YwHsIM-9{^8&nz?Ab1dX5NoPG-Sav$``+)$HlCSAFa6#|WN%(;$qBh+bdWojw7ZjA+*)rHCJW1IAInze(-IWYe*E+*pu zy(zXUdU>f9Jw}NBWXNy9~wa^65jOZP55j6uAB~d0PrwtPvC7{zYSK z0hDuzt*AX|3s04_-qQs+cCiEtIX)v~;iW@#g_y`TPwtKw=4KiE@bBVX>`X8mF{?4xq?tUmi#z0kj9($YC+@nx>Gf&o^}_A}s_Js{i|z#^wyFOnvgj)K0@ z?CbdHz1S~Ko9%q~;oo}=f87Xog6=<&VYdl)&8_6K<1orLjz$m}3Q@-UG%z8IdnXue z4GQqwx~(?jX=s7!0Pi77r&v#o{{0J&8}wzl$RM$0TI)r^9JH660xK2%ARAqA-ph+t z1G3VLN7p2@(o8c3hY&LvCWQjib!it+jnvw zf!Vd@!+&%MtYeLVO*uXIperw1j;cjSAKr5Gez`ff*&&F9aj-xVi%gSY?JSv)e{&4d zs=1*8+e0C0=;1Y#FQNckdj<`#d#cUqv0KHehyVD4_aIE|Ym)8uNMYgL@osPKDmNyz z%k>k?>wTn#V39exw|T= zD{lzjy6usD6ks<;TX_e5?AU04Eqgxv#oxfG&A01}9&D)XF4f6vvRbN~K59Zd8#(e& zZUS;UOsXd9nfOE&1c&`>1GuHpG64p(3BVMmJASw|M{w`~*>IqizZtIah8qVz{3jp0 z2Y26x|MY|J{?@xYJAUcN^Go~r^H-m|dg(8|I4`Q6)?(xNM=}tLk`h9ghN*~4AI&O3 zAt`CA@9O0`+DxyFaHqt+(}UpcvBrjo7_C^~ zw2-zufL8)ZUaOAG8DhF|Lvn|KF$g`8o__kQ%iop<6m+ZgUXaFboM6b!f;)|e|LiMJ ze|LcQJ-eZ9bkH^#4g8WzujcR?HInCPbjfj$>@%0GX3DI#G|hd#c>eJZo_zT1)vXHg&I9*oDTS{} zDer=oJ66~(J9%KqX6jo&NVhdMdERg2YDzu4w^kBu0C92EzC zN#kXGloVk6Cg9OkBlcW}8=;*r13vk9_|LzBX|KIWD1!&qPj4{lw{Bw`7j&WB`_`i{ z+#xk(@ql-q8{6&#v-MsCJ#xZnx<-LWme@F50v}j&pyCbCsx~IC9aE7D?g$_lS=R{D zD)v}SwHY^s6g5`(f{(d!={7V>ByhF1shed%oJEdP!2l=U2)wI8;V6_4%0P8IxZ>c> zv)kNf9W}<3$6>3rlW4%7i|qUHw%;$jOpjML>;0XF?(x=tzi$1%i-N$td+pz}{=drB z|GgzQUo!>J?dN)T5zw2@^-BVv*B`9q1eq-1nOh-Sx)|!HtL+6o;Ds5L01}XHI)F+P zdfH4niWk6a$7;j>YF0W(i8Z!copAwaXcHA$n0h3*EH6)3X99Nf{qPqrS0^e)EW?C{ z3!w}{Bf%F(ri=`3{S;70MP9nA)@pd3yY&Mz&01~w1-vp5Ljj7Q8>(ijTMatLXd=BZ z*RIu>wn;mbBm#1h+Isje9uF?UmX0tLL>dn7**J-Ir?kR7nLBTh5hp^<5bMhmreNA5 zu`as^ie%I~;ZBhNw$nrzcU)3};8xXLQfym>hoXr>umqvUgq1|DBRTHkM z1)>ie!z~#2XH*AtqjS$4J;XN9zU96k%WrN6xzim`Xsr&>{~i-I|1BT_^@I9b?4#b# zEWK`Q-}~)c8xMcn^SE}^pi72Nz@}Bf9s*m@BHB(e&?aBH~$A4 z*prv>ji%)WU zmgDg6vhwuJix>ow1#0c&(=qV7mF+bfVa7Kc32C3{mei+A#Ba_sW9~E23yT?vj!YuV zq$BUl+VHp$H_CMDG7W7R0?!fB#FOU?$-O%;N{Nz9w_FQ+CU2O0eOr&Mt3^Z25sc51 zeS_r8GO-ZsoUPIE7_G!&RZiuzC$JW?qqdGS;x&(~KFJ^C$FFWHm3JPtFW+4M=8II} zyPv()zwzT2AN_UwH}$9dl>ge#KKQ?8fBNjhSI<8F8{+v#FZ|V?|Lhv%ZS)jcJ=Wwd4hw0CJSt5MReYx|mq2$0j#FV^M0ugG9eb8JDQ-SM%cDdFhrYqx&HytWAB)0s>fAOf8hYHP zt?EOP528=!tQigUXBo?49J?+n-TSG&UcN6xj_>{G#SL`j&ck+Fctp*CzFc^G{ld>) zcev*FBH7(5;UxXF48j;1l#E`AYWjr7`@L*#euW>8eMJTI=0}S(HvnYXV&62DAfuk ziDH37b07Spm8KL>gm}#3?cu+^RC6$!Y__h&JJ*S3Oen8*6tf1ZLuc>uM8?zHg2Tf= z?AQ`!9c`axhTE%SYI+-65T%6L*@S|xuhrq_n1ITWvK$f+Cm0zQd+Eb}b5Y+o?Mf`U zlXD|6Vy`w6GFt&~WA;{X)gY{dbkWLcitH6n260M3N{kdfy9c6IcDEBlyet~^i3At| z;F=?LJJH+0{CAPrYma#NZ!fY|#9Vpf6Obg+SZhftR7^U<)>Llibxz;dT2ZG9WI8sg zr|q5SXy|GcpobP%Wm9Am%>hYU6I~PiY{dWefj*NYuF{HoCOk$D|J_9=w|3U*l6bn~ zY+34aq=l8%jHEsqiMk6kdTOmrsm(ci&eIYJ(ZO>yHQa^L3#zuW=jjE&7%G(Q!i2PA zfE`;|8<3SDh;@2<`0p)|kmP3qdZQ-DY|KWp+2;Fw%y6B#i(#2YB zMFA|gi|=hEz1gM4c#v8M^-slgZ!M4<*TbXnh2>YFqrw{-5#VIDA&Q=s3aSrTpIo^( zoDudjwolQA|M7$O0NwTQKYj4s-*|UokuNr)U;P{u^}Qc`NiH(ia*CrP(HM0DQx6hB z#frW149r2BiYswhaYuAWp$i86lh_soC&7GCw37?niXH1TN4ZZ~H)kwGszI4<1|sV) zf{Ce%o!gV+ed%=9PK3{>fiLrW`3E;nggcMjBgCk;AwK+mLVWg^(+FLVhMg*WOLBR~ zE!2D=@uFFz_SUnxZ#P6{sN_7doieQSm$utzhC6jU(>Ovx@{t1hy7;L_Mmz#Hh>d_kPWIhVt#5*sl5#oV+$90?N z&ghzJIo!wo@$+XlFw}bw+RZJ6pYq#egf}m|Khy2=q5PH0K70A|)A)Rwg$HGAa!%bd z>G0x-z`haL_fR{5VqkRF>NR@~^a?it+N`Z*^jJ2_`gX`mX6#~oOI(Z$vf~bvP^;cF z*lQ2;*eh79UBvU(rSp5Ui>{{OuYHp7>C1d=<$mFhK%wtFevd4FcD4N3d%67SfPD%# zm9nxC(o<~o;4`&nD1_noIw#kR-Ta__d)kh*PYIO`jV1_~N@d%r5Qx{NXigp0 zz@cgA>$05`>WJd)a~3?P2d%a1cJRHutk);K_`ZMm`!}N8JCE7TQa7%&=;Qt5-=nnQ zr}1ovlBX5i$8gP5>V1qjZTL86Adh)gD@HK|LL)?Ak-*p@=ddn}M(^W5|H1BF@ODA6 zIC2fsn9jM`=9+zMv4*PQT-So2dpnk|=Gq^<$lZDP9wpL_DaU6E)N*J-e=RwUBCY6q-^-Jt-mUnPq}x4xucETu}A&+{ZhRN}NchB4)%7&WoW9 zTBRistH#c?8Z>;)fEuZ~b{DwXc1XaHaBNtak|S4bp6H&oR{+(!SgiHUVs*Qgr^!m{4aPH z69wp1Ban(}rH99WuEG!=l%>6Fw${7NOLigf>IlsqF(FCBVT#ck+Hz1HA7Vs|?4!AC zSPMF6)6_h@C)I(hwL>ZnfmZj^^5K8QyWm+9)NXV^dS}vD(FIK?HjRY7uS18Dd)u1Op86gGH-lL_b+Y2tCIbK(J;>EN1D6LJ?*X4N(8DgXC(ljvz@141 z*Jdn_=Py5g^20~YefJ)?o8@pm<+t(&UVr`GZNMi)OPh4*M@Q?HBve{e=mAI$3fcni zDO4lOtOaxPgtqU%VyvaAoL~#WN`zV)GL~~FWwplm7Ja8EU#J-kRDk0H&m7Lz7v7)Q_Ss1OBIOrNd3;Zk!wIt{=u_XPrm>B`OSKF?{RxHhM--=5WI)?+&Bt_LjjfGY2GQ4 z0*8-@hnE54X|!}9Q&tc$-el2E>H)`aq@aH)1wH?k4z+Nd#ygH~CfX;oH-J%4)t%(S zpk1ASpmOJ%_3qwanXCEsE8qL@`34sB(y_hKU)_7~zOLbdo#TX~m2@hB4%h-&bRq1E z2M?r&HywG}pabR#+;J#`LFz2U3yjdR^yx}!X2Lj;s(uh!2+yq1WT z7l`)c8fkrRR?}^$)Oi-qt|!~Q2kqumXHVPP;?g%Sym!-W;0(S4X>UFHaGgd^roxn_9uRLQ@gwOfIW7BnAaDG`4vsIi-8u)aBFQP*54yuf*`mi;n8EV zoG58-3M3}$CBit|*meod%v`H>AD+FBJSk`KB&ZTk?FdlLXf<1by4sY%jOzJlOO|P_ z>;3TFZ|Bjz>bLi&RrwOm`$v3n#EHrUEFybhbEDQzxV2sad-GX+&OMU7ckK2Hwa$Hl z_Z(8B4Z__L0!fU+5F$3iXzDyGH@TbXybM|a_CMy1hI{~oy~7(m zwod%}OSXYmU4NkWemjqTpuh6zt9mk@{J=kacKlU7O39e;r1sf+koY7+nE^a#p9p6j zgcMj8>s^Dm?Nhdvlb=iB?G3| zbL}f1Nr2D5e=dZvnQXMj2;e8~qyDctY-n8W-y&jFT-cUc`E zl+QlOZ#~FUdiolQQG_{r$yJpx{ZgjI)htdrkIYrzO~LWp`Wi42(4tATspO)A$3I*l zkS)OhK1Yo+)M1atZx#>)WlgGBY?lYDGMaK*HrcPm%J+Ud*H_;^^6}K(n#d~HED?X2 zYcWAQQ?JV`(DEPHi|pj^p;>t`$Q;qRxBD2gDa`XzsJa5G+`zM2j5~i@2Z^J?y8{95 z11|d*Ia-Er-=&{>k$?Ah2Ev_xYA^DartFpN`0AIx`rBW7V@m$9|M_pe`3FDgyL|Ug zUs2~)D@$*-4be7d1uub7R@)xj{9^TL`y7erLv_CO3pQ^g-rpFQ-$yt64Q}qfBld`_wD&Lb=Dzjjh4=1$vTO*) zWo1X`3@suX8y?31u0T=0eLygaWndSzbwpKtaFN!4p9=+ugg&=(fz-Ir{Vta1#-J{t z!wI7jSS@VPH;GYpo`NpJI;Ra8dhNEnGez>+ZTaHUkAD>Skgk(%?>uael$iPHwY~j4 ztoF?_g0?|P{#uS1!P1IjG(|OS>sYZllg@BqhHNt|aK<>;rAZqLpKp%dBgj02^*JNyf+)3u-c-r%$Aqx!4wzkL4c)ra})24#8gfqQhq(ba@| z4@-VarTWRWj(2M?5AO{)S*gPp+5o3$N#MA7_<~?&AG6-=w9}2HP2pi1ZLD1tZC*ez zGg@DZ7mT3_Wz|?ZSlqj`UJksI#1_9U`Q1CW%g84m z`HLr?eEQHQV_pyc$5+9Q z8K7O}RAu6m0MI2YWWFxe>I){YPl6EB7}dZra1Mu4H=#Ge!j-ZnwLL5kut*EsXxKHl z4_pyzEXbVmOr#t%kSTP}wXp5pwD#@{zP!H2eDcGaJ^tP!_UN%vu8x)R4(2<-^+Qv!4vYL3*qi{pbu{B)M_+cOi8_&EIGp&W*jUtu3~;A?Q^moHM5c9d@zfVr=M^ z_t8M7TN8|camHCYnzr%qe_q6zD8pHsR{TALOEV9`ds6y6pX!>broN!i{W{;v-Z1NaSu^e=4) z>AhKzUsH6YOzORv3${0aI-s2J3M5-lL2|2TIl^5;z2ME9+86PLYADguK|9iTb|^SX z&kBV-uJ^u&!6M@8Qe9=zb-d|9oyvPAQsdTt?Y(F()C_?Zv@kg7VzUAzwbF&h^_q2W*w)p2`}O>T7tcS=k6%6W51(w0-+x|pbC$dF z2tLAadAnZ2?`ORR2~8>!w5*i6xJ?tag47cY6%qt|O@aV{LaMT7G8=&uFfMcP*1$HgzGv%%Xg8>pCo%RbZ0B}ek-j%z?b`PCy_X(YpMLnHZq~Yc zkK9ccL@ucVU+RLqdEvdAb7-1>1`RW1+$G?{v7#1xa`UlT8^C6-7JHOtEpj`)7VSB_-{pPo8{nqcXVnkbPZAX`wJnAWR~?k2;8!Koe5X6tyFhMn`FH%1&s$dlapuvyIKk z&_0zXT=>yJ%47(awmOfME!vPiR-0nDHKHXya)YUVwys>&ov$UWceblv@2<~2{(ioE zb_?Xc_pm)W-Q;Sz{mjMScR$?-o6m{EKny~m>r(?rbQScvw~BT`@G1z!sY_r~MSKD3 z_bYXu#R~Fu`S5*-=mSD8AsjiW4*wQl;3yjn0*^$i1kMOBI_26nd2cSkwU+ObeD&hx z^H3dmaqJ=%6HtRN9&AmzoPg$hQkN`1(>RJidJk~eGIy@&15HLhK)aqr=UwQMYFeJoJ<`&OSEX$EsELhfxL&wawCeMET+EoIKr zS*uw#U0IPG2kI(9boSgwxn*#J_1aozprozxfI!!w07&+s?xFjpNOEu9$hD5@)$_}{ zdsfeG?-BPNx<_$T?FvWr9!|M|SSVnS&gSKc?9tdAa&H?Awb-#}Y(a&hRGZ?K-daI& z?=(-K-xo@>%`)A3pI$`Lr&!-SoS_t6Q(6NWqE{DRWy_bW?6X~m0^b|=E$F+X|}rE)-PwFhCs1k(5nm3_h1?!X_U%R%RP(_vm|zgMYmjZBznAdMax| zdI+UBjg!2gR*^$+0UpDO(8d%*(Pcx36fTCG#fZETwH}9v9{%rlDPQ^Q!+g!PfAQ*z zOLH6UC@m;VDojGd9C9fhE5_~{Y?HY=%DLK2&l$)Y@}ZL%5O&(KWutuz=LOE$`z#XZ zOrUi?>-Hvd??{2`PVNuC|Lhk3ckeO#`4kD?1KRt;|MN~C zf^T0U9bSK=zl2BO^2aZpg-fb5JU$2>cf6!ZGSzk7uxxlttpT;ERADI;Xjbyj3I z(&4ih61Lj3b@=hJ-sVY$TFyk~nrXm|U(G~94QO&YjxvVKg=}b(U({3x*;+KhzH0mM z@FVNt-@8I_dN<;P#mN*9*+NvWIuDpv&feoV5iCJw93=zwJ#Uyzdl%iVjQ5T|dgM5G_WXCjQi|Vw)Z)4Gz&&bU6Z+L( zDS7_l=YR0iFNl4d(@*lTabgQHHf;KEP-qufz`g@LN}UZu&W3$^t|@avEEQl_2!8KG zjFDqq25{#MA+rLrwk>JxIH$%+I4;yLS{Vf?HF@}Vehr(Z2`e24A7?Nxz{g|Lj_$}S zkfe6${sf|E0Tgg7#UP%EINRfH=;D>Fr1X^9MSOC4R~SF{(n+9Ep9Zeb6etWgAeTo? z^7zAl__P4_r@N?j)Q9$@y0%aO>s)wdEEr9qXqN6ZB|NNq7ir$qMjv)KJT{1yZPkgc z8wK}e(W!S@zORHRFqXOuAf2$vx2>r2hi@~8ByQ`!_m(=}c2~3h^k@F@qpRwj2kps1 zT)!#Ay@&qUG3G`%&Ee)MM60ch(r6zoAdWon<#85j`TeA#sRX;%bu;V1d(kvLJSn;# z?`$goWN48ScY{7+^aQ}r<_4M&tM8hqbuQv_8-sCgMf=TU`=g(|st;fN?(_X&{ovDj z`P@JL@YSa;UOuwZ-g^|EsL73+uEThD$e(+Q>;Hn*|1W6$@2vH2xD<>w@N9G=B_5RP zwNu*O8%*G4s1)+a)GS9r)3NDl3axl+)u*Y(!UYmVM`6U0-~^haOQcwNHXLWge61#F zyb~N(TxaBqr}&pb>u>j!`Y)ah68ICbt1nqh+@;0XI;eJ?L3rn2W`r!R(CeRy2*}Qf zv<_f*CrQo?De9U@_~t}78(Iv|2;y*7Y>qREj1PFK;}pl>+bMK!YvLEn!5{onFQ4W2 z>UZknkH5&!{1jSP_(wl^_WY4J@!rGugm<)mXT9Ma#m_(eRf2KiI@G8#1|pw);}lTY zsV^~iqCtmw%)@6ZpL0?{LouB(8gx~;Tzv=iMSeQkrBE0?g)g5I28n=Cd7(~E)>Dnw7IQ@bsP8@~xv{s^8Yq0*toqqy9T}2oP38iP z1qcszIyAa0I873}Ih`viOIMrN!{I*PkmR&UyFdKL@8Bw7tW5g^%SF7@IA@3tJHpMF z(Na#8y`^6PZ%7@vjL1wHO_hsqi#>Z+e_eW5YoCriigvL$v7VafNmJq&HW~}>ebx{f zd)x{&qoPmE+az_;1_PqW;y^7DCef&r#ckfYq>KZ@3b90R!UyF~` zy&I*Vs&B*7g`h}PfvgG=13uJjp1nOzCZV(CN@zB+A^kdRw8hI>^fotW&J3z6Y0cgi zUu8X%(+Eec5)MeMgVeirnIsSY$yG&TIj$pY%V-*0Ytfc~KR$_V?p~dtdSGkK9U}2{ z8rPU3YeW|`-aN;dW2_j77+BUYi#UPU!v$F^x^;Vrx0nf*qSvfe(qcdSr&kQjlyn!? zK@mr!ks}$*2jOaq;>$L&Lz)A#(Jv8E&3QbKa|ilJV;!pnmeSFQfSX!_dMy-MtI1>; zLq-|8_r+8x@F=k6+4=CF;Zwv)YBn&f;ZKKvQWzY|LCEU}*$pO6Dv=!I8l(F%eC2cGy)A zKh5ANPb9@g?>^RUI2W#Jnz1T|E$@TO0oc;BcXOus@Lyh^!aD3Gwnyt#3N?1At6bg~ zV@c?8C-uv`#M&3O(*YZnpL2?mO#9g(5*?0p^HuAT(4z8m8VrysaDBLd)WzjCi zJCgenRZ27gwhB(9asWKpIg0HvJlNq*1KX`U{MWB*|DaE3zy;xLp%|i0pdF*IN$6Dd z4Q0KfB#VEkXB>P6wM1g_nqD^?i959GKsN=0yd?^Jwzv+v-{q%xu5y) z-(2sA(ah=Kqs1K67Z$009gES+G6r5Cp$v^}7@^U9H+L`5y*xHa?O`SPt6mPw(c0qb2QNA z%r;PyS%~s#I)Y@s%6$lF?=c5WGv-u9|#3D1!>T$AJ9t8w$6wD4xeJi zLC>)FvAQ*^_!@w#%{P)-CDH*Zx6|@cN({S*td<`xNt(ai5h}KhS%EiBt#anKfldn_Ii>eE{%a zit?#yC_Hwbjj$Hb2D*kfI%^k?W=d;NV|DB{w@V{KM)3`aDig}KE6iWdi zGPZ&UFQVEyZ>pW>Aa*)^UcvF(YpKy`Ep1+zd=owQs3v17K-_qI$Lp+-*bavuq+HBB z8nvq;gwV(F@V~zP6xq*K2SonRf*^_@&cc-eFToyX!jX~FPt}5sbmmz><=GeV(c9KD zAdn$6faFTVLWeRY%8c2d8oka5QMkWMuPzqrx&V7U{BQUa!yzW6)JwFAzXNsun3KpE zM4`Se_6ou-=QdIJ*_8&ck>C;6=}v4K(T=u>PAR(l%O`xxIMi*Q&6?U_Pqw6PE;&-m zPf|Sm?^h@Lpu9zC)R6~^O}?ld6%npNx0F?C>O`NJu($&`CPIyOEv-|G|Ec2E7Z6$E zU0A2cIgu9yVHSb*e0U^g#5tuxJ3>hFoQMD8TUXdq8?z=pr!49S{RVP~=^AZV!G5}|iB4Dw8p#KA#OmxdousPy6g zyv`TG>$sP=*cw`z9@J4r7Me>lXFrk#z5QO>m()ogz2q`ZbIjmayN1+N6^FqvxZ6B{ zlrA@+>Nt86d~2sz4ou~CJR_-wWlr= zT@j#!Y&Klq8%_rpl7L+$l~By67T$6rmG|Hc=}2}uEsUV#N zfB6SL^6&oo4}UlPh-UF{Nly)@BPUC@E^VT?e9PP8 zuReSJ;?E}OuE-v*h zIf)8dKQ+!>C{P}%YDRTNP%v(6Q0F;r7(3L~zT~h~QZ2%|a6+nb1cW^BpSs{CHUxA? zu7Sjn;k_gxkv{_Eo0AjyBeTJs_3gJB4v%CS`p1aam~XG?!Soh@qXGxJgUybDSwiJNT+m#uOSd&3v)wL*@@*|>b{k}{GrNfvns8;gBS%xzVH$C3Fl;iavd5Z1%d-dM zw`e=`RvxFZ)+2quy|u_+GOOr%6el_ z*7tAfsiW+duS--#uy{|vs9DoOgPUO)oZw(J8cHL! zh5}}8V`z6L-D5Fiemo5q(LfJ|2j?U9{=Eh0w|nY-@#43hJ(_Iy9<(RjqV2{l`aV%- zKA&uy5y@yhoQQ^cbYH_z3AKc^h9wL93vE8fUo2Y?n~3im=1Fo|VVkI3d?Ttu-jhbT}0C~LG>0X^%wYG*dtmh??!!<&# zK%WAp>f{(%&7C}qon|$N_8h4ks6vWoE=DI&13`7-E>j==-)~)X*%3haOx{EpXv)Tg z5SlDUyB^3P&?Zkc5{9dwr;SK%bFFGeD4OL?)E$GxOvYZqV_X?7+=po`(Ngh1!52AO zS4&vhn8P0azpH}U_kayy3Zb$e^SmxM4jR0Oozz#oh2?UeO;bnF-=o=kR<^}sd&~j%OjBJ!SpIylhqq90 zd*`0*;jhN0kPA+}_>A31mfFhDqbNjbHC7#=WZfnNE^zZ)Pq`HYFIBsb#o2*fZ@YYr ztc?gVkl7FFx$9)Jg?m|`tbZDYggWx*5fpgN!(W3>F}bdAC||T@Yr5tVOhi8zxZxI< zP)FOMHVx%k(;ZNb?&`c*_hko!E)1P5Z7`VRakS?q@(KDryb_6~;9M!5B@8S!M$MM= z@YjCu-CzCMRqB`EN;U`^-5L>U*vJfl;(+=E)y*f*Lmg9R5*`wunen-AD zzp@;^{`nnA(vL;Qw-bO@fD|%_4T?`ks2{2nP+7CLFqx*8+%~r!J7;h>hiiDmL5?Ux z?tvAGy&wRxy@#!V$n(Y>`RU>d(FA;Hv$fK0Eo}GxI8RE_fBBPV`^ESD)BVvCf@VW| zX7n_RHuk}ENbBJ_(5laCV;=4*(beY|-m)|o2kU6)szo|yTUHGA zOqcz`xYA#G=$HOner)OamtXHDoAQr*u1SB(fB){!zsXheDH?{{v8jDs1tS|s2^w{A z+2d@&X#~DB=&eCzX_0oaHQ>v%hL+^f*J-pOq7EqkN?JB{=e|(+lCk$yQHpXp%FU2L zHEyj=@9!MCMXKF-+#c;Da$~KN_tRQ;Hc_la#jm57XXw}r5IjuZYXNC8h*?%j9|j-} zl(W0{VXz~Nvsz&tHk7KNs|EfO{^DSpeSxY6l&4z8knMxJJ45S$+_bpO;mS9lyGfZ;7LL0t4& zVH+!~pP@kHQ1%IpG25`Q=U#rc*uW)Q$OHmKM~2dooM#-!8aomdx30D+I}L%BZJdmu zKKjF7_rcd6oi(~tBq0k5XuLe3aM9pVR02*q;OFRu5AWzi_3lQlm)t2PNRu)zCcTtf z)%D#vt}DsYhDmP)a4kx`yW$|T(!>Mjs?2_i6TCO3;T9oq!BswdsyKY_fqT;R({Efq zUq=-M`eXpEZMEHMhMa8x#!T1=7OER(GqhN)!?BqtS~W0}Gqy~fNXNxA*QFA0`e<>3 z93OJsCW}HHVmukmNT}~3L8}k>qHE~GUw>5&q@nAxSLdmajP3=JER2&&cz5eHC+V)U z$kF#y-BQ!nu#uVUJbXeQJsUF4mH;hUZigKDyBT}8@+Fhj7I%Mbeh4070!H`4-|)dZ z00_jECS$D@L0yWgf!AiJPF#09lMVA13_1ERn=C2JO!koMgt38>K#0zWM~ zxc$4$zWW)r))9oq9lC4)B%Nt^yG;YQx4-M{2E1Q+S+8Dv{M+^6XD^>UdJ*qDh(D|G zCupfBZ|uM{Yjy?aG-lr{NCgBkFbfd0!pd{ZV;wkj6NqpG6O98fzRI2hq{11Yt#k)YSZhTgruv_KBoo#(@pL~D#b$lq&LlG*vA04~zJdjT^1>}Y) z@E+o`E7)q!xqOXS+hfjw;Tu&M8`Md#&xR2&lkH5%pOJFZW|$#@t(EtU`$vva-~*5Z zf?$!$<)M8}&FIi$$7Sn=hj9VxD~#04+bonjGrQh;?9R`=|H)&z?7c_tiSx&NW7fU? z`DdT#_A_=nd!j<9!lSIMJS|%^8L&xd^%2bvO$VUZleH8Vm$qk5NZ~^ku(#r8G+JUo zu&^;*K$CXTChgTxy5tE!e3>FSr&WTEJ!eCwMAFkWjRVuvl5vLz4`BzEX z79&Hix09J(36(^xjgow;lT)eToH9qm%+)YKsLaVfk zEF$d%CDE1*KKaAnc(q|xoZQvV8U*9YMqh=;If&<*UZ-PcoZX>fgCz}^ za^fRfHsMz`jAayd5Q{znb@mIa)Hg2{AarG&)%%{SHByy_zv+YT{^HlJz~D~3xgli- zFl!#XyV}u1L)IQsrIAR*DsGqEr~$M^Geze%>a+Y77@ z`D6Q&&;I!9@BXg$d0_SDjIkR6YtWgrS=O=#H)%d7W?q@tYuoD7*45nBwM(L?cixFz zSy2bc>b55>%f>ZdvPQCP;YzbtwVyo&vhG`bvvW)NTVSmeH{EOc3h}=%ddynBe zn~=YO3Hkb)e?BQ+fB$!0^X*n}zoJ#k&E3;lOZXf|9i_cCL;E*p2hM5N0xgmi1Q|Ge zHFj(Jz^e?BMsg%DSzcFlk!pB z_s%2u&ZgwAJvAl20c|*+fWvk+Z@sPnB?S(k>Du0F8<#pLV<8*lR6(@GLdrmk2ooZ! z2G8RbYc>5c?xLDS4Q1+bH%LNiAY5lwAdPMe8&ME*J!(SSnQrmtn~*b^tx&SvDVzj*b> zUw`p$bkpvGsW(DWN50ss6**h-X#5DcduQs+Tc+e6{L;4j=ooqD0eoi@@`Kw6 z`Aw{lSK#4H=xH+{zOB`}@06~JstQQuP+yM0t9TW8UtF_E#Rds&F!X|PXd`N>LCI+- zIg%jJX_>}qxg#d<2N!Z2COJ!+AvNi-*6F_Zqqkjb-mro{+O+RHhVS%Z^Z7UbM%PG? z^CzfysMj4xNtG)ib$OGM=Ui*a$(aL8of*^C+!7aRBxfA~Cq*eZL>f?=OUKcctLGGP zu%8zBV4TV)Ph-$nl1W%-K1vwBHx27;=g6-R1|IL)_Z`7^dX9W^N`51&Bx<&3+G|#8 z&igdm*$@}Cd9T)%@)RFxA%Vv5>*3X5Jg3JPs7NoKLqhm$a$JrNia{ zSq11nunQbnsH(TeM#TGq(cU&8zXG3l0x)~m5qzf;^7`K2>xV&#?MD>O zlL?C4>ByJGnzVtbTXUhr>wMC>4>*hGNM|?flw$p20bPo%v32V>yTu~taG@rLZNIbS zmTlYktlN6zy%~9LD~|tgLOzz6-go@oX>t5!I==JCIP22k!ix^8`ijJZ$&Hp2hbF*q ztURQUW|tg&`x&sc4A1GamRO<=At6P`v>#xinTpS|eYGK+b9QTMA}tlk7@^X5tke6x zHO$-_mH4(R&6jwc+u3;U0eq)dny=2r>&w6U)1yvkRWl$4H#K5V#@eu>8@T;;7P@uV#?Q-b}}P zGc(_IrFjF{^!WUE-!XirSDLTR$S=PCJ6|KA_3G$vh>tZlUe)L^CL4qi30_VfXRV?E zSF~t01aAxj;sjSo?cHJF%93N{U^0rvsbrX`U7(PlcA~`sgR*JceV;LXM7u5f+#8|# zmPz@C-XwuNS|{&3i0^Dx{?VIR`NIKt=Pks>3?(dddzMYwpjw`A#8d`bWYcqir5p{z zX+t(BsK#BPLkZ{}79VMgMjs5VkCer{Y{I*p>1_m^wYy0{{NoutN}zB!d@D@4H&gfb zzSuk|v$*#Neq$G#Z$@Zg4GCJsf|U3kZRc8J;gB^>(+QjU8hzTH+)s9zU{I{H#~5xk zM|2d~{18$Y-Facq2Y|IqC7dM<7Wp;zykNRAHs{O(vV!z;dzQR6UitUlyg$blK8lpM z^B8_(oA(#r|DAKFR$B*_k-lZ4XR5&8uDzPcLRsakY}9nm8M24w!9*xDK$MsUWg;Bp z2(6Z_^_H~}_Ho)iryOd@zTDfIvv*)^8v~X?xcUN9_Q>OKU)uKXy-Hp*%tsiiJCEQu zwo1PK_V0Q^%0^tZB8Gml5?o=*5;9Mf8)diAoA*5^DgoB82sQSl)#ijrvAj>n`n*82 zmKDmV=rcU8rvbKe>5fU8^-XqisY9p=ttq=cOJlZT9JHXLVgn~WLQ6Yqf-H2R_{54 z2hTWqn$O7yitV@`nCz6jYA7UPbM7g2fY^FHXYilVlnwOBnljW2XZ96m*9;rA?Yb|| z4Ha%3+IE`N?fLQEsT^;+)V#qLe{_Pp^BBIus{2N^(op)4oCE$Aew4)c`P#bbS z%(SG(l#^+Ba*wSGVs6`DAYY4sv35b9wwl8%V!+H^Y*|`kiis(8BLF9s)PSyMHY@^Y zV$f|*``#ffZ@bid1zZ0JA%5o(e5aS1H>cz`u}ap(yPmcX$`Zb{gGE*o?mfwky4ave zV~MObo#&aF3^GDmb2j+rXvCxi*ZUD-u%k{nj~sGz9&-^ieUQLU`n+z4Q3J(@V|ut-nd-xX9?;UDn)9*O1tHS_nMtT$ezB#>{9QnNW|y zU$8ZBvpfxNcGCsF$j<8Uvh;2YH&qCb6tK}lJ-D?ncdO;S7v%mW3cYMbfp#6I9e9fb57v~kv?-ZmO4Xi7MQ)N9%~>oP0M6MCCDbMGj(w{6xx%mI3|S>Jj5 z-sxuj)!F#XoE+sUiD>FLz||g{dxUsiJIf(rp`$^b0+PXzQBtSFCKb8>vYTtqvBr_J zd*kCww99AMLM%+4F{0GQEQy_BZm<#5+|^p$0(empmLm}MH=lWWEd;;h6-RH}Th-`6 zWYVIf4~dm~F;>udCWI3{tAop|FuaPGteO`v`Q_SZ7}}$opuvj`R^-;dut# zb!HozMq7gs3es1rq`?|6=_ed6hCr*`qRjg`lb6yiYrJXrg?93>xz$o-nKUCy{o!xD zJ_QJfyr@rQ^(NJ7WRK<5ATV3_9GRg&vgSgSkylE>N61~z8GUV@k+zoO8#1L2tASSH zKHvtFLZDgbb_3J_=c3{#Kib+O*U_Cn&dm$^tNX?CPwV-o9|Ac11Pmu_uh@ZnA>>`5 zg@*1Gj~|G+7lY0fjv5q~1dl7I=dmt(WXJzZ7cDStLVRb-R?}&I%ho!TIq%!J) zJ~hF{QS`frTh}*XILK6a4Z}IMt4=2%gnGti(e6`ZtqmXu5+(ZaKFYB3N;66xT%f?) z+Gh~3;*N>!&=A&`4r3L~zD;ONm{uU+N)<+!L-0U83<@fyo5sW6_Q87)mGkho<5M&g z5l1Yx!3$>wJ3uQ2@|0wMw-W}evwSUaQf(j!VsARVe@g4xqqWP(B*yG{P{u-W$iXqto2JaQVJs}glZu05nG?)yEJ=ERL;kj`Q ztm;YZS#TqdxwJAm5(l=X^@dex0Ld|#ZS$5$>fw91fON>kb z7VLg~@;+lZcl-}R0;E(vI5`JY%enFRGh)CyJbU<2THr0rGkA{CRn~S{@X}e+Bn6Qk zbkA7bb(s*ncB*Wr+I;vsuf&X9=MZ~`vMNt&Wjt!Z54x?d^h2WB54JGLa^M2gO{SPn z@RbrbP@2wmaI6CDhff>`2?w~ktxL7m&PIjjN|xD|qKg`FOn>;hE>x4zs2a>`Q6Fqg zR(P%ieF858_$tzkYUWUH&fWTHYZ8xsdavQb4MAawNF7@s?OJvoic`QzJ6nlyab9~1 z+>}Go+TxjThv&oJeUV5hr*4vVQPD=8a)2)uf;AMLF7Uv{K_hV((CS3slO|58*SJV&z%6AO5}%F2EVgO1+&rmr5Ti6zE92N#Wd0?m86tztyw?R5;iQw_cHKyu1L z<+TDX_;64sHk=9*VSk4(3~DZL5VR}cU2YjW{% zJ2_**7HHE!$I~@gE+ewr_A%5_*48*MBktj%A$4f>;&U9hv9`QIcft~2)Y={eLj$HU z^cXZzB03DC^e)_x2RCd#`tXn7Q=pW7P;IKEv#T7meq20OJJh7-X)!cL^f_t+;M_L1 z$Sf!yO;IC2?tvAu4>ebgjCE~+c&z6fWK*OvWaFf58Mfl7!YxWqd-z9R&x^%NXF8WP zTI~RJvHH@LZ2-9?)mNR>r`FCz!ALF$3k@TzmDdTLJ&|=)+(+V%+^ZsMb8(wxf|^vc z0JyCP8ucn0ea`fUf9$$Vn91p)h?v#9fZAupZl|R!bS`88QoL07M53rqT88bj5!aC= z&T2(goZb4yg5QcAcIGp4AEbXx-RSWHi_@3o5xt_AoF_m0U43Jl1fWWv!P0WZiGlQ}wuj-Sw;%rL557CU{zNVvuk%rH7{XQ*SoLdcbPHz8 zeR@M$SW@h>HYm8$-I0$*@UPEw;JBKuhW0V4)eI2nrD9OWi16&>HHU_iXrbT&h1Hyg zZsm^mPQ!Z?#`)2U-+BH-Cf9uj?a6>^dV?uWKYe-U9RPZK^rqQo!Zo^V9SHYXCeAN( zaJ+%!m~nMZZPs#bZY;2**n%rqNdT8W%nGS|sBWZaTvcd7die~3vIO-8EbfRsU&}kH z5OUjSxp(N{&1Czf?>~F~>=S=nO}zK8J(0-yCc<9dPlWwhg7Y2Bku_#)FYt}DA$!R# zGn%2A*A95z$TKjTv5vux;+7-Vs1^cJh(Je=I3{#45Gr!YDG6Y=(`2fH>e0R; zUz%e+wrwTbjDl!JXY>(X>BOf1tCeABUbVJnq97x;l81X|i{5roe%C+#_}QyZADON0 zJZevLQRt?N@?LJUkZV#QdAM?KNBQfb$|bZ*(e!Yl1mTPro8F}i*L}vxs5|$?ZH}JW z+gQGZ7~Z^=ak}Ehw0n&5gz!C4=R|BugyMRKTYWuBPBhb&uGr9i%4+m**bn z)@GpOPKe_PVKp0L(^&!?K1Z@5rYT$+i+K4gG_*R-0{t3EvS>Hg@$kNlHQ>iO-wyZ87#Y9RAXQr<7}*AkV7lPq;wM*%4U7y}aC zDL67mA6lbCRzf$rtY@Rn3weK$yOT9E%y%tWSkqCjL9!Vw&ExZ+yy(-!7=*vm0h=ot zDY*yg)1`}YwugV_y7xe=sSBi-gWCF*h7_oYT9P+vq3z+H#iv*eb<(^ZXM>2I2}gAp z-uGzAvb;y&*5-^2wXX^66WC&=2oZ+!-A*X4z2RI72%0Hx0Zx$&MszLY?54 z)Wz%pisa#+yXrxEYH!g4!2^wDat(3hvR+m7i_oakZ0U%7e4I5jkkblFq70v7UcH~g zq&!Y^TA=I>+)27Z9|^7`mctbVnJ)NMXj9pgnVTQ}`K!m`W2Bj??df8eVptdUI{Tr63#TJH$I z2stRZ5AeLs4sB)%85L3o`#8B5eo^(gSMOr%aj*-1wX=MkT&~WthWT}5GfvWq))lcYvb9lA zJ#iW%%d_X~G-Xfb~D>DwE%WYpvR*Nt+ zhD)hrG#55neEIa!QPxkE_VBNM@ZI0|+O5PhCiig=K)86@Lbl8V+NZVaqE>aWUzQbh zoxC85TND;P0X<(89f(pyvBNM1*=HFm<%W``g$-edO7#Kpb?2$CvY-3`v*p_;kia9Pdg%9#kty%g;@gPsv%=3EnP zK8__FgnAt@C*=_U`C~V=p5+@13%VMpHiBU*oE0uAyi{DbB%koxg&CfWbs&6Tym1jw zp3DuaP#uWxyxHjv#aFeqhBRBlOC*PDgv99VmGN5ckk#DD!`Nw7i_?bJRUP3F&s?~! zGA;-TC5(KT5Aci6Ub*jAKg7De`tWTD#?>K^aIapqrp2RX%OOq`C1 zp}aFR;W&D1*A*J#Z6N^4)yfQ5{J~lsPjXu&&Q&=I_Q}a-!6an1p)55Y3Zn*uz^W6QIbmJylu$D?fe~kBWVF9=0co zeeI^$_fuDv--Aj2v(kBZd~R)sXm910-O?8puyC~&T6p}WM8lO~BHfKvM1}6E~A)FvgxW7+xFNAeS2GpK~na3)WPs=8)={q9{3$q;#yf zuS;nLElSrVIE;{DftUlFsI_iQ7xzxpep`&>FV_!teS){_QL*;U1NcPDZF^%WdHwTy zcW?_1*r!SQK@#V3t&uPz;K&OWE=zCoO3&ixtqWgFusle!wi5!f!@3$PO4KQLV`(sT zL10?Vnj0gtEg>PTb?&7GTQITw|#!wlZ<@B~Q2=$aynTUUX)F`-j;_DZS-mkuT_B;_O z|MH{HzF7Ev?%CtE{GCVdiMBl5wB^5s!_zyss%~Vu3H)1LGsqc&a~+(?1=&oaaVE~p zI?w9K3CjRfopYBJ3g1IB3d}Q$e(0P78YJx~-3y|5f?iLd_hMYGICkzn0^;eqg<9P^ z;rC|6`$Mlj`{a`sFF$?t;g#6@=$d-x!F$}BqBonOzxeqdym!;iL_v7nZ50~7xOS^8 zSW#`BFp(mlmyn|A4MsXWS}A@U-p)mPslgV5dmOcFe1>#acQm=@1mKKq+1v}-hcmL& zA_oEL(2{SBQTKNA+)TSavR}OTt!MS&t7qSP?w@}4vL2o9?mT=ytLM9k)Hj@};EL=6 zie{I?p=ZujVbsLuKm%eLSYyP%%fbp}J<%%AjSl9D#DzC&Lx z0p$XL>biiD2m=wW^fDvBI@zpi?zx*Q=UGi~z2}`c_V@CD(0_wahxJ7Sdm}-Lk4L^W zsAuhc;MB24YuueZayOIhm+Sd{k@eZjNA&x9kK3d9)^3zW?fu+SVFG9kG6E231=_DI z2M!*sg4)5+X=5agN`wwCI1tTKJw{kXLgU=ML-b%3tiVO2mR37EQa}htCwH{mok`me z_60aYX)$Z(uyqRymQm?juQXhWw>GvPcxI2&BlULS$b7lRh6-HnGj2q$|66joP z1T;W%#8RvgsSv$7at&hB+NE)*O{cAb2BdB2gog={N&z%;(H<~Gf)94Q1J4w4gJn$o zJZ`=3hWxe|7Q6=uqWA?MUk$U7h6a)Z|Kybg<>H?0SBfJ~w zYSoFF4MQ;!7R+UBZx6Eu#ze-sde%_=tt&%1tgo^h(-2`9D#0BA_SWiHAS3*0KJF@@ z4^H_~%iBuay^Y(CB)j$Ud-dU$y{SjFxOegPC1olT`%C?dr7DYD{7~z&OdyF1JowEqz6Z--g&J~U?Z3{^)mrSLJV|`hM_mU^}*cR^?nN{ zx;ovTx49loxjPTtll3>gslUC4r#SRp_UvJM;+ZJY;b-5+&*GzxVHQUq< z9}{B4nKBrHT$t9}6I6>Pd^W^e-WfE(ylMee=ZvFhadQ_u6$IVNqYJ~m4fVGx+^bLh z)6ZT#ZmHgT*q+=_+s%ghK33p5Dh54-GDfdDbJ(PqLwG}_Ke9@qo!PsBm08HyV`Mk4 zR!vF!2(%{qgqhrBw3LQNP-s8_=-MWVRc*BvTWof!#rq1|1G?uC-1xpsx|`|t!58?o zeD>;-7q6Z@B_z4`2tHXEp_|Ic*TGI4LI!BAs2NnNE4EAIBvoE4uvD$v|}%$|@Q%Z>C{z82}RMC-77?|~ZR zXmic3kSDg)`#6CE7|~oyKo2eu$2Q1Py>lQj9!UR8Tj`AwcY!{)3Y>#Id0GV$Oo7Yh zhAD6A$o28GK6z&3!@u$LjK2iy;iE6$aH2t`y2++E5&(1A^0oi~np$&oIxKro!a4{q z{1IM5I3Aj(u+&B>L33Vf9Cgn``7=(HLrj3_xelU z{rNZV5rj03wURc%y1NV4aFfQ{b7%xoX^~pXV?skOfkM=o)GdeZt&Olk@y1+bq>Fi{ zF^$kbsF<@Uz2<6+@)*5CQZYm)MAKuR+e*oup@uhe=?{MY+4t+i*NesNP2$c2_ssxB z;IBJ1$w3I?RUMLS@Iz~%7Yr6X@uuCpYA@e@NeyCLpnGiFU4Sm$xUx0DB^)O{mGChK z60K)WortyrWcU#BGD$_IxeWwwO@H_|-@$oqk)kPjP-N2v?!i7F8K}=KZGsi!1*2AT z6epBz(n!=2mi3Oi>B41?%pIu?r!Ch#D#L{YVP~5Su|K0}D3A_S8yR>@=S=Ol_nCWB zG;ce+FP?vRo;`o|>Z8ird4KPbd*TND=BciIO{cmUqBSOxtM?%f5;2H&x3sJSnV5-F zL#SLkan^Eh01OmG5YqrB8hukg=6a%L^o0|P)wJk_usO;1!mRFgunNYJ#lfDn~S@AEf@EN z0Bzc`A>CmRPe2vYm{@VN^*T1Alg(;y>#fy2T2{ahdU{_65u#Z3M~>lpNXs=(_mNE| z5@dmF*kc|^4$Bd-M<=!^b#ziZ{MmPLagVmFGgoATRLgzsv8h{Z9}`jEeGh|&0svJz zHrhs>Wz3O^O&TWDg zO!%Ms(~k|qcOI}uO6>U^eq+A>;^%+xHKcs3h1&06P4EU$KvO$Z&4T%eo$Ly*Q{r*( zwp`PAt>`E|MH^7D7>lpVzN#`xduuF^uM;?@Do8aw2C!`&X|^f4j@CATGxqRrzYEJS z`few>C+?(isl28X^&k~;hTEJ6t5K!^0HPqOfIU#PP;v?D(8rrV{#<9$^p0{{Q=e2g zlO)n!na1t`HXgYdEr`1J(OY5ez3D?Y6aLpe`t;LJKHR=Pst;e)_x<^&&-SBN;NC;{ zMB%EvvEsk}`Mqlrh^98Jrd1tsFouC`57avv&=<|S;LgogJy4x^Q0!uBYzOMmHpNb<3ahfT{Uzd3*GzeLbS0cc7T`&8clYlNjYH zL9`g+I!luBt+j4}DGM#wJOz3(H%r>i1 z?R&S{VCmXyka;@~uZe6RaN5S8~3K~VAg z6tMQX0RCoo1vp3{IXCoSvf0wkln`&&Dr~I4Aol6qCYYQewG$y1i{J)bDU_Xubdg%H z^K?BjV_)Sbgk+)w*L7llP3?p@5B1sw+zD3j+xEzV^H^@D$R{s9{_*d=@0oYUkVg;P zvm1lmYz+1WHU?ivcom?z$6S47V}ZAQ9h9=?m;~Q~I8rBdHrP>z%4}uelv}X3jws_H z-9Xw4z^`b72y6~b5qTR(W~5wJ-j;VV+*vM9KAoq3^nwFkO#?t@W_L7u2ZhWz$|E~x zTeF`t!SReGllDr4QO%y)6zSOIjvy&#o&b@*9qqr$O@84)3j zLvC$w7YDXV$&-Dc5m7-=G_APw(8X%+d+?lV?^`(Fqk*rty~&>tiQcadet2&)c=X_X zJ;0B502KA~kH3Y=%UC$}HnVCYsU3(vwg_0#Jao@OLMDz=Fs%(>S`%Ruj6#yurc>KG z5bq7(aQw8fH*X7&QDs8H}@iV#TcIrQxGJI!t_{r4&3wDPhKveDpk?w2AQtS zC^ep;fI^+aKu4Eos!Y38+di0LeA}ga_3Gt|ySDU$hwL68({BMXZ>p^E==b&MpLh$K z=R5@|Cs4J!G`x<;mCWG2kf>8f=7h3<7hnoJaXem>biM!3#T;bO`B})u&7SF`z_^jL z6ScE^dJQ>3(9p2(3@D4c%st9(L4}Ww=DRKBp-l7sJ*(@{qxS5Ljc#siZ$gam=)Cn` z#=pOf`1kR;c+I>?JDcua4BaKX{3?xj0(l5_uWuw8R-SDw0*AM28ICADRY-S12EoY9 z*j5%0a}+>vYK7Toj{rAxQa`W#TtnCjQ>H-uUih1RFN8dHQM_ z3NC0ODq0sr`D(K{ccVn@%VQ(i)0&BvOrIBGnByWjxdZkvf3TayzbMPyf^v|1E@&QX2G&W)3e!OJ-03}mc? z5Gu>3ZKk>VmQLrY=pF-oCn0B6yNaO*ra+p^+E|pDj$(K;*V8}!7OIMFv}<&M9esC^ zCPuEUX^4;2<$ zYh)_|Q%(rot=b2%R<>wC=-}wKM9$Ce;{B)1-baJazCj$e`!BUI;E<~wi0zKnTA-B9 z6%p0jPPdv6;my9fEQVs=T&kbp%NU7-fSZEh+O_o!(Mp@H$6#r)vGB#2z&NEsDmtNk zBmmQQ51Dj-=;!N8eKZW^o5E(f|3*(uNt?Z9fH&V0I}g{Dzz)7K>JkkAMnmstN^>2E zN`y>%uW39-Qx60hH}r~H?_Ou(0vHV|HsarETw5D_s0ds}WF{9nU~+ejBZneJmvyyGb0rs~SQ}DzY7tINF^n5S)Z5un z0TD%GzL;c9F8%Y`Cv?F#03Z{(dWAP-8N}IoNKVxr0xV0h;ec4Ugr9xu_}(Mb=9aao zS<^%F^x}pLsn!ueV(wwOUHZ%vxNKFAbCTh-*mG!aR%o6?=Ys~d?178FE-jcXmyd%Z zKwFLte{RW^G!shoyh}NI^#i{T*?#nx-4$WmcbR{-f%&b^e((kgQiDVD2*nBH^0scr zRt(i1CV@lrR9pre#UGk*h=eTUEC{062I2i8aIuwp@7N7@XI1q0$F8~zf*D(=r9?`r zM3U}7OP7W`{j)gi3nLD0OdY3o>exqB>kQj$sHNA;Sy}s7!j3mvKa&S_G3m|Gz+OER zgx5I-vKU*lzSo+=6Bje7c~*%*w2>Vw2i?L(a}P`+e){L|6azO+FiwW>q!GL9DnlSG z13P66sOTqZj9v4b!3st;PQSV58j29*=Fvs$D6D{@r*I=_9_rYEnrk6*CwI~!PtUbh z5-{AfpZ@vRS&IP4@X0c7W+62aMpjc+4cdp7Zw3U=d?>daP+fxK%!6Yo^~#wD z{%)WU?(8wxK}Ms6eg`Y}i44uAa{!*(V^eJ#{pnx8Q=kP}&W#R%fX=%-;kcVyj_n4| zW81P;Z%|OdFBWI#Y{>ErWC5O06Wvai)^ju_2Ul

oawb&!&P63jsxngtlW|c%LEJ z^zrmBUU{YqovRbF+u5Cap8}qMolQkp?IXG4<-SgJc4`bjJs}J}aALbqL5Y-%@P`fS z0(UOPdp)Mw0VZtC>l_#kFQ6Ui9x$D!vSd&)kW3+nu z8`p(c&pGah)6UIdbH{?s_TlOzG^Xt}Mixyv#O4h;J)Zc>D@&G-i#Y)Rki)?R z@`T`ekJ!>7T@T#5^X!R|7tl5Q;rBr@ z87wi26cen^JW&g+`I2aIxJI+uqc%z50{C3r2YBfh#qKvRe=S6}O7 zWo)i7g$>;|=|hlfoqcNV)t~;AD}@>5=PC>GX~;$qojMf|8@d2waI-eAmT0fFHWe09 z_#_9RK+JyVaM}igVXe7$WOc--&uX+e=279%A$Cv##C6T|)`HqJl6v}Auk~Wj6Ji^x zY@Ffu22W)R#y}I8jkSs#N7}w$C+6ZHgezR(4Opt%C)q(!lUC&FU034fbarOsXp68n z^E?%(qA+nnREEYi_osgiPqDY|C8r&pIIZ>Msch4)KwUu!B%MkUy`qVvw-u3nqQ>13 zJt~4}5aXWeB_~>cut? zy-t|$vYHQ`ID=f0XqyX`CY#u2XWxJUKwUIS3|FZ{8O#PwI_5AMEO$n8)bQV{Nav@2 z=XGj3J330*w(kHLOW0@TXl-t-357=z%ihaCHAN)_weTY?=3+pDeQct%ZB$IF^CE#v zp-O8c^Ego28l

Ref>HPdP3j;%6`R$BpD6KdNXo^e4oM5Fce?_DRp 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 DVE) +# AUTH0_CLIENT_ID +# AUTH0_CLIENT_SECRET + +# AI binding for future features +[ai] +binding = "AI" + +# Observability +[observability] +enabled = true + +# Development configuration +[dev] +port = 8787 +local_protocol = "http" diff --git a/mcp-worker/yarn.lock b/mcp-worker/yarn.lock new file mode 100644 index 000000000..b580e9df2 --- /dev/null +++ b/mcp-worker/yarn.lock @@ -0,0 +1,2848 @@ +# This file is generated by running "yarn install" inside your project. +# Manual changes might be lost - proceed with caution! + +__metadata: + version: 8 + cacheKey: 10c0 + +"@ai-sdk/provider-utils@npm:2.2.8": + version: 2.2.8 + resolution: "@ai-sdk/provider-utils@npm:2.2.8" + dependencies: + "@ai-sdk/provider": "npm:1.1.3" + nanoid: "npm:^3.3.8" + secure-json-parse: "npm:^2.7.0" + peerDependencies: + zod: ^3.23.8 + checksum: 10c0/34c72bf5f23f2d3e7aef496da7099422ba3b3ff243c35511853e16c3f1528717500262eea32b19e3e09bc4452152a5f31e650512f53f08a5f5645d907bff429e + languageName: node + linkType: hard + +"@ai-sdk/provider@npm:1.1.3": + version: 1.1.3 + resolution: "@ai-sdk/provider@npm:1.1.3" + dependencies: + json-schema: "npm:^0.4.0" + checksum: 10c0/40e080e223328e7c89829865e9c48f4ce8442a6a59f7ed5dfbdb4f63e8d859a76641e2d31e91970dd389bddb910f32ec7c3dbb0ce583c119e5a1e614ea7b8bc4 + languageName: node + linkType: hard + +"@ai-sdk/react@npm:1.2.12": + version: 1.2.12 + resolution: "@ai-sdk/react@npm:1.2.12" + dependencies: + "@ai-sdk/provider-utils": "npm:2.2.8" + "@ai-sdk/ui-utils": "npm:1.2.11" + swr: "npm:^2.2.5" + throttleit: "npm:2.1.0" + peerDependencies: + react: ^18 || ^19 || ^19.0.0-rc + zod: ^3.23.8 + peerDependenciesMeta: + zod: + optional: true + checksum: 10c0/5422feb4ffeebd3287441cf658733e9ad7f9081fc279e85f57700d7fe9f4ed8a0504789c1be695790df44b28730e525cf12acf0f52bfa5adecc561ffd00cb2a5 + languageName: node + linkType: hard + +"@ai-sdk/ui-utils@npm:1.2.11": + version: 1.2.11 + resolution: "@ai-sdk/ui-utils@npm:1.2.11" + dependencies: + "@ai-sdk/provider": "npm:1.1.3" + "@ai-sdk/provider-utils": "npm:2.2.8" + zod-to-json-schema: "npm:^3.24.1" + peerDependencies: + zod: ^3.23.8 + checksum: 10c0/de0a10f9e16010126a21a1690aaf56d545b9c0f8d8b2cc33ffd22c2bb2e914949acb9b3f86e0e39a0e4b0d4f24db12e2b094045e34b311de0c8f84bfab48cc92 + languageName: node + linkType: hard + +"@cloudflare/kv-asset-handler@npm:0.4.0": + version: 0.4.0 + resolution: "@cloudflare/kv-asset-handler@npm:0.4.0" + dependencies: + mime: "npm:^3.0.0" + checksum: 10c0/54273c796d9815294599d7958a1a4e342f5519a03cc24c9501cf24d8721de9dbb8c53262941acb0e058bd9e952f807e3e1caa3ae242a0eabc26b1d2caa9a26f6 + languageName: node + linkType: hard + +"@cloudflare/unenv-preset@npm:2.4.1": + version: 2.4.1 + resolution: "@cloudflare/unenv-preset@npm:2.4.1" + peerDependencies: + unenv: 2.0.0-rc.17 + workerd: ^1.20250521.0 + peerDependenciesMeta: + workerd: + optional: true + checksum: 10c0/29e2db8949b56c634044a50e812c1089ba59a72fe736d80d5b3e6caffc64f45a5636e1f69f8f7af329321334b101a01aa9cb935f556fb6ea69375ad4e76833b8 + languageName: node + linkType: hard + +"@cloudflare/workerd-darwin-64@npm:1.20250712.0": + version: 1.20250712.0 + resolution: "@cloudflare/workerd-darwin-64@npm:1.20250712.0" + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@cloudflare/workerd-darwin-arm64@npm:1.20250712.0": + version: 1.20250712.0 + resolution: "@cloudflare/workerd-darwin-arm64@npm:1.20250712.0" + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@cloudflare/workerd-linux-64@npm:1.20250712.0": + version: 1.20250712.0 + resolution: "@cloudflare/workerd-linux-64@npm:1.20250712.0" + conditions: os=linux & cpu=x64 + languageName: node + linkType: hard + +"@cloudflare/workerd-linux-arm64@npm:1.20250712.0": + version: 1.20250712.0 + resolution: "@cloudflare/workerd-linux-arm64@npm:1.20250712.0" + conditions: os=linux & cpu=arm64 + languageName: node + linkType: hard + +"@cloudflare/workerd-windows-64@npm:1.20250712.0": + version: 1.20250712.0 + resolution: "@cloudflare/workerd-windows-64@npm:1.20250712.0" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + +"@cloudflare/workers-oauth-provider@npm:^0.0.5": + version: 0.0.5 + resolution: "@cloudflare/workers-oauth-provider@npm:0.0.5" + dependencies: + "@cloudflare/workers-types": "npm:^4.20250311.0" + checksum: 10c0/d1d9e57c4570952235e892baeef60318dea57bfa2109acc9ecea94cdc5aef0a65ef58382173cae10811e2eca8b3a8fdd906001f3b89a393059f61c6a30226915 + languageName: node + linkType: hard + +"@cloudflare/workers-types@npm:^4.20250311.0": + version: 4.20250726.0 + resolution: "@cloudflare/workers-types@npm:4.20250726.0" + checksum: 10c0/91c708039cf51bbf6d46b1052508c3c308c425b624281fbd26152e967bcff6d92b9946621fea1fcf0538188d96c0280754b5bb1ca1f003675adb8a4f4b7e44de + languageName: node + linkType: hard + +"@cspotcode/source-map-support@npm:0.8.1": + version: 0.8.1 + resolution: "@cspotcode/source-map-support@npm:0.8.1" + dependencies: + "@jridgewell/trace-mapping": "npm:0.3.9" + checksum: 10c0/05c5368c13b662ee4c122c7bfbe5dc0b613416672a829f3e78bc49a357a197e0218d6e74e7c66cfcd04e15a179acab080bd3c69658c9fbefd0e1ccd950a07fc6 + languageName: node + linkType: hard + +"@devcycle/mcp-worker@workspace:.": + version: 0.0.0-use.local + resolution: "@devcycle/mcp-worker@workspace:." + dependencies: + "@cloudflare/workers-oauth-provider": "npm:^0.0.5" + "@modelcontextprotocol/sdk": "npm:^1.15.0" + "@types/node": "npm:^24.0.10" + agents: "npm:^0.0.100" + hono: "npm:^4.8.4" + jose: "npm:^6.0.11" + oauth4webapi: "npm:^3.5.5" + typescript: "npm:^5.8.3" + wrangler: "npm:^4.22.0" + zod: "npm:^3.24.2" + languageName: unknown + linkType: soft + +"@emnapi/runtime@npm:^1.2.0": + version: 1.4.5 + resolution: "@emnapi/runtime@npm:1.4.5" + dependencies: + tslib: "npm:^2.4.0" + checksum: 10c0/37a0278be5ac81e918efe36f1449875cbafba947039c53c65a1f8fc238001b866446fc66041513b286baaff5d6f9bec667f5164b3ca481373a8d9cb65bfc984b + languageName: node + linkType: hard + +"@esbuild/aix-ppc64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/aix-ppc64@npm:0.25.4" + conditions: os=aix & cpu=ppc64 + languageName: node + linkType: hard + +"@esbuild/android-arm64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/android-arm64@npm:0.25.4" + conditions: os=android & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/android-arm@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/android-arm@npm:0.25.4" + conditions: os=android & cpu=arm + languageName: node + linkType: hard + +"@esbuild/android-x64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/android-x64@npm:0.25.4" + conditions: os=android & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/darwin-arm64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/darwin-arm64@npm:0.25.4" + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/darwin-x64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/darwin-x64@npm:0.25.4" + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/freebsd-arm64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/freebsd-arm64@npm:0.25.4" + conditions: os=freebsd & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/freebsd-x64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/freebsd-x64@npm:0.25.4" + conditions: os=freebsd & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/linux-arm64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/linux-arm64@npm:0.25.4" + conditions: os=linux & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/linux-arm@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/linux-arm@npm:0.25.4" + conditions: os=linux & cpu=arm + languageName: node + linkType: hard + +"@esbuild/linux-ia32@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/linux-ia32@npm:0.25.4" + conditions: os=linux & cpu=ia32 + languageName: node + linkType: hard + +"@esbuild/linux-loong64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/linux-loong64@npm:0.25.4" + conditions: os=linux & cpu=loong64 + languageName: node + linkType: hard + +"@esbuild/linux-mips64el@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/linux-mips64el@npm:0.25.4" + conditions: os=linux & cpu=mips64el + languageName: node + linkType: hard + +"@esbuild/linux-ppc64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/linux-ppc64@npm:0.25.4" + conditions: os=linux & cpu=ppc64 + languageName: node + linkType: hard + +"@esbuild/linux-riscv64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/linux-riscv64@npm:0.25.4" + conditions: os=linux & cpu=riscv64 + languageName: node + linkType: hard + +"@esbuild/linux-s390x@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/linux-s390x@npm:0.25.4" + conditions: os=linux & cpu=s390x + languageName: node + linkType: hard + +"@esbuild/linux-x64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/linux-x64@npm:0.25.4" + conditions: os=linux & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/netbsd-arm64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/netbsd-arm64@npm:0.25.4" + conditions: os=netbsd & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/netbsd-x64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/netbsd-x64@npm:0.25.4" + conditions: os=netbsd & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/openbsd-arm64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/openbsd-arm64@npm:0.25.4" + conditions: os=openbsd & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/openbsd-x64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/openbsd-x64@npm:0.25.4" + conditions: os=openbsd & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/sunos-x64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/sunos-x64@npm:0.25.4" + conditions: os=sunos & cpu=x64 + languageName: node + linkType: hard + +"@esbuild/win32-arm64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/win32-arm64@npm:0.25.4" + conditions: os=win32 & cpu=arm64 + languageName: node + linkType: hard + +"@esbuild/win32-ia32@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/win32-ia32@npm:0.25.4" + conditions: os=win32 & cpu=ia32 + languageName: node + linkType: hard + +"@esbuild/win32-x64@npm:0.25.4": + version: 0.25.4 + resolution: "@esbuild/win32-x64@npm:0.25.4" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + +"@img/sharp-darwin-arm64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-darwin-arm64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-darwin-arm64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-darwin-arm64": + optional: true + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@img/sharp-darwin-x64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-darwin-x64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-darwin-x64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-darwin-x64": + optional: true + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@img/sharp-libvips-darwin-arm64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-darwin-arm64@npm:1.0.4" + conditions: os=darwin & cpu=arm64 + languageName: node + linkType: hard + +"@img/sharp-libvips-darwin-x64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-darwin-x64@npm:1.0.4" + conditions: os=darwin & cpu=x64 + languageName: node + linkType: hard + +"@img/sharp-libvips-linux-arm64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-linux-arm64@npm:1.0.4" + conditions: os=linux & cpu=arm64 & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-libvips-linux-arm@npm:1.0.5": + version: 1.0.5 + resolution: "@img/sharp-libvips-linux-arm@npm:1.0.5" + conditions: os=linux & cpu=arm & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-libvips-linux-s390x@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-linux-s390x@npm:1.0.4" + conditions: os=linux & cpu=s390x & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-libvips-linux-x64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-linux-x64@npm:1.0.4" + conditions: os=linux & cpu=x64 & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-libvips-linuxmusl-arm64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-linuxmusl-arm64@npm:1.0.4" + conditions: os=linux & cpu=arm64 & libc=musl + languageName: node + linkType: hard + +"@img/sharp-libvips-linuxmusl-x64@npm:1.0.4": + version: 1.0.4 + resolution: "@img/sharp-libvips-linuxmusl-x64@npm:1.0.4" + conditions: os=linux & cpu=x64 & libc=musl + languageName: node + linkType: hard + +"@img/sharp-linux-arm64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linux-arm64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linux-arm64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-linux-arm64": + optional: true + conditions: os=linux & cpu=arm64 & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-linux-arm@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linux-arm@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linux-arm": "npm:1.0.5" + dependenciesMeta: + "@img/sharp-libvips-linux-arm": + optional: true + conditions: os=linux & cpu=arm & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-linux-s390x@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linux-s390x@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linux-s390x": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-linux-s390x": + optional: true + conditions: os=linux & cpu=s390x & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-linux-x64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linux-x64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linux-x64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-linux-x64": + optional: true + conditions: os=linux & cpu=x64 & libc=glibc + languageName: node + linkType: hard + +"@img/sharp-linuxmusl-arm64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linuxmusl-arm64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linuxmusl-arm64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-linuxmusl-arm64": + optional: true + conditions: os=linux & cpu=arm64 & libc=musl + languageName: node + linkType: hard + +"@img/sharp-linuxmusl-x64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-linuxmusl-x64@npm:0.33.5" + dependencies: + "@img/sharp-libvips-linuxmusl-x64": "npm:1.0.4" + dependenciesMeta: + "@img/sharp-libvips-linuxmusl-x64": + optional: true + conditions: os=linux & cpu=x64 & libc=musl + languageName: node + linkType: hard + +"@img/sharp-wasm32@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-wasm32@npm:0.33.5" + dependencies: + "@emnapi/runtime": "npm:^1.2.0" + conditions: cpu=wasm32 + languageName: node + linkType: hard + +"@img/sharp-win32-ia32@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-win32-ia32@npm:0.33.5" + conditions: os=win32 & cpu=ia32 + languageName: node + linkType: hard + +"@img/sharp-win32-x64@npm:0.33.5": + version: 0.33.5 + resolution: "@img/sharp-win32-x64@npm:0.33.5" + conditions: os=win32 & cpu=x64 + languageName: node + linkType: hard + +"@isaacs/cliui@npm:^8.0.2": + version: 8.0.2 + resolution: "@isaacs/cliui@npm:8.0.2" + dependencies: + string-width: "npm:^5.1.2" + string-width-cjs: "npm:string-width@^4.2.0" + strip-ansi: "npm:^7.0.1" + strip-ansi-cjs: "npm:strip-ansi@^6.0.1" + wrap-ansi: "npm:^8.1.0" + wrap-ansi-cjs: "npm:wrap-ansi@^7.0.0" + checksum: 10c0/b1bf42535d49f11dc137f18d5e4e63a28c5569de438a221c369483731e9dac9fb797af554e8bf02b6192d1e5eba6e6402cf93900c3d0ac86391d00d04876789e + languageName: node + linkType: hard + +"@isaacs/fs-minipass@npm:^4.0.0": + version: 4.0.1 + resolution: "@isaacs/fs-minipass@npm:4.0.1" + dependencies: + minipass: "npm:^7.0.4" + checksum: 10c0/c25b6dc1598790d5b55c0947a9b7d111cfa92594db5296c3b907e2f533c033666f692a3939eadac17b1c7c40d362d0b0635dc874cbfe3e70db7c2b07cc97a5d2 + languageName: node + linkType: hard + +"@jridgewell/resolve-uri@npm:^3.0.3": + version: 3.1.2 + resolution: "@jridgewell/resolve-uri@npm:3.1.2" + checksum: 10c0/d502e6fb516b35032331406d4e962c21fe77cdf1cbdb49c6142bcbd9e30507094b18972778a6e27cbad756209cfe34b1a27729e6fa08a2eb92b33943f680cf1e + languageName: node + linkType: hard + +"@jridgewell/sourcemap-codec@npm:^1.4.10": + version: 1.5.4 + resolution: "@jridgewell/sourcemap-codec@npm:1.5.4" + checksum: 10c0/c5aab3e6362a8dd94ad80ab90845730c825fc4c8d9cf07ebca7a2eb8a832d155d62558800fc41d42785f989ddbb21db6df004d1786e8ecb65e428ab8dff71309 + languageName: node + linkType: hard + +"@jridgewell/trace-mapping@npm:0.3.9": + version: 0.3.9 + resolution: "@jridgewell/trace-mapping@npm:0.3.9" + dependencies: + "@jridgewell/resolve-uri": "npm:^3.0.3" + "@jridgewell/sourcemap-codec": "npm:^1.4.10" + checksum: 10c0/fa425b606d7c7ee5bfa6a31a7b050dd5814b4082f318e0e4190f991902181b4330f43f4805db1dd4f2433fd0ed9cc7a7b9c2683f1deeab1df1b0a98b1e24055b + languageName: node + linkType: hard + +"@modelcontextprotocol/sdk@npm:^1.13.1, @modelcontextprotocol/sdk@npm:^1.15.0": + version: 1.17.0 + resolution: "@modelcontextprotocol/sdk@npm:1.17.0" + dependencies: + ajv: "npm:^6.12.6" + content-type: "npm:^1.0.5" + cors: "npm:^2.8.5" + cross-spawn: "npm:^7.0.5" + eventsource: "npm:^3.0.2" + eventsource-parser: "npm:^3.0.0" + express: "npm:^5.0.1" + express-rate-limit: "npm:^7.5.0" + pkce-challenge: "npm:^5.0.0" + raw-body: "npm:^3.0.0" + zod: "npm:^3.23.8" + zod-to-json-schema: "npm:^3.24.1" + checksum: 10c0/ac497edeb05a434bf8092475e4354ec602644b0197735d3bcd809ee1922f2078ab71e7d8d9dbe1c42765978fa3f2f807df01a2a3ad421c986f0b2207c3a40a68 + languageName: node + linkType: hard + +"@npmcli/agent@npm:^3.0.0": + version: 3.0.0 + resolution: "@npmcli/agent@npm:3.0.0" + dependencies: + agent-base: "npm:^7.1.0" + http-proxy-agent: "npm:^7.0.0" + https-proxy-agent: "npm:^7.0.1" + lru-cache: "npm:^10.0.1" + socks-proxy-agent: "npm:^8.0.3" + checksum: 10c0/efe37b982f30740ee77696a80c196912c274ecd2cb243bc6ae7053a50c733ce0f6c09fda085145f33ecf453be19654acca74b69e81eaad4c90f00ccffe2f9271 + languageName: node + linkType: hard + +"@npmcli/fs@npm:^4.0.0": + version: 4.0.0 + resolution: "@npmcli/fs@npm:4.0.0" + dependencies: + semver: "npm:^7.3.5" + checksum: 10c0/c90935d5ce670c87b6b14fab04a965a3b8137e585f8b2a6257263bd7f97756dd736cb165bb470e5156a9e718ecd99413dccc54b1138c1a46d6ec7cf325982fe5 + languageName: node + linkType: hard + +"@opentelemetry/api@npm:1.9.0": + version: 1.9.0 + resolution: "@opentelemetry/api@npm:1.9.0" + checksum: 10c0/9aae2fe6e8a3a3eeb6c1fdef78e1939cf05a0f37f8a4fae4d6bf2e09eb1e06f966ece85805626e01ba5fab48072b94f19b835449e58b6d26720ee19a58298add + languageName: node + linkType: hard + +"@pkgjs/parseargs@npm:^0.11.0": + version: 0.11.0 + resolution: "@pkgjs/parseargs@npm:0.11.0" + checksum: 10c0/5bd7576bb1b38a47a7fc7b51ac9f38748e772beebc56200450c4a817d712232b8f1d3ef70532c80840243c657d491cf6a6be1e3a214cff907645819fdc34aadd + languageName: node + linkType: hard + +"@poppinss/colors@npm:^4.1.5": + version: 4.1.5 + resolution: "@poppinss/colors@npm:4.1.5" + dependencies: + kleur: "npm:^4.1.5" + checksum: 10c0/e9d5c9e9a8c1eb7cd37e9b431bda7b7573476be7395123b26815d758f38ca93db0ba62bb2831281f4f04a6e1620b4d4f9377268d32c61c2c9f6599a02c2112b7 + languageName: node + linkType: hard + +"@poppinss/dumper@npm:^0.6.4": + version: 0.6.4 + resolution: "@poppinss/dumper@npm:0.6.4" + dependencies: + "@poppinss/colors": "npm:^4.1.5" + "@sindresorhus/is": "npm:^7.0.2" + supports-color: "npm:^10.0.0" + checksum: 10c0/1eb1716af39fae7cc294f8fd60d10527c26bd82cd9e6438ffc71face9d6a198a3af713e7f73ef4800b1a19b99003467023ec2c5d308c38d3ba958a12d0a91989 + languageName: node + linkType: hard + +"@poppinss/exception@npm:^1.2.2": + version: 1.2.2 + resolution: "@poppinss/exception@npm:1.2.2" + checksum: 10c0/b14d1e3d532230f58238231fce6ba3bf51dab50d4ec015f3192f04320be1d692eadd831a8d437e2fc345787c96350104149fd9920264362bca143d04ec03bc4e + languageName: node + linkType: hard + +"@sindresorhus/is@npm:^7.0.2": + version: 7.0.2 + resolution: "@sindresorhus/is@npm:7.0.2" + checksum: 10c0/50881c9b651e189972087de9104e0d259a2a0dc93c604e863b3be1847e31c3dce685e76a41c0ae92198ae02b36d30d07b723a2d72015ce3cf910afc6dc337ff5 + languageName: node + linkType: hard + +"@speed-highlight/core@npm:^1.2.7": + version: 1.2.7 + resolution: "@speed-highlight/core@npm:1.2.7" + checksum: 10c0/33905da58b7e0f0857f3ec7c60a4d2e7bd7e25573dd8676de2dab555057e9873084fd2bb1d97c4629131a990f7e230cb7068045370a15c77c4412527776791d4 + languageName: node + linkType: hard + +"@types/diff-match-patch@npm:^1.0.36": + version: 1.0.36 + resolution: "@types/diff-match-patch@npm:1.0.36" + checksum: 10c0/0bad011ab138baa8bde94e7815064bb881f010452463272644ddbbb0590659cb93f7aa2776ff442c6721d70f202839e1053f8aa62d801cc4166f7a3ea9130055 + languageName: node + linkType: hard + +"@types/node@npm:^24.0.10": + version: 24.1.0 + resolution: "@types/node@npm:24.1.0" + dependencies: + undici-types: "npm:~7.8.0" + checksum: 10c0/6c4686bc144f6ce7bffd4cadc3e1196e2217c1da4c639c637213719c8a3ee58b6c596b994befcbffeacd9d9eb0c3bff6529d2bc27da5d1cb9d58b1da0056f9f4 + languageName: node + linkType: hard + +"abbrev@npm:^3.0.0": + version: 3.0.1 + resolution: "abbrev@npm:3.0.1" + checksum: 10c0/21ba8f574ea57a3106d6d35623f2c4a9111d9ee3e9a5be47baed46ec2457d2eac46e07a5c4a60186f88cb98abbe3e24f2d4cca70bc2b12f1692523e2209a9ccf + languageName: node + linkType: hard + +"accepts@npm:^2.0.0": + version: 2.0.0 + resolution: "accepts@npm:2.0.0" + dependencies: + mime-types: "npm:^3.0.0" + negotiator: "npm:^1.0.0" + checksum: 10c0/98374742097e140891546076215f90c32644feacf652db48412329de4c2a529178a81aa500fbb13dd3e6cbf6e68d829037b123ac037fc9a08bcec4b87b358eef + languageName: node + linkType: hard + +"acorn-walk@npm:8.3.2": + version: 8.3.2 + resolution: "acorn-walk@npm:8.3.2" + checksum: 10c0/7e2a8dad5480df7f872569b9dccff2f3da7e65f5353686b1d6032ab9f4ddf6e3a2cb83a9b52cf50b1497fd522154dda92f0abf7153290cc79cd14721ff121e52 + languageName: node + linkType: hard + +"acorn@npm:8.14.0": + version: 8.14.0 + resolution: "acorn@npm:8.14.0" + bin: + acorn: bin/acorn + checksum: 10c0/6d4ee461a7734b2f48836ee0fbb752903606e576cc100eb49340295129ca0b452f3ba91ddd4424a1d4406a98adfb2ebb6bd0ff4c49d7a0930c10e462719bbfd7 + languageName: node + linkType: hard + +"agent-base@npm:^7.1.0, agent-base@npm:^7.1.2": + version: 7.1.4 + resolution: "agent-base@npm:7.1.4" + checksum: 10c0/c2c9ab7599692d594b6a161559ada307b7a624fa4c7b03e3afdb5a5e31cd0e53269115b620fcab024c5ac6a6f37fa5eb2e004f076ad30f5f7e6b8b671f7b35fe + languageName: node + linkType: hard + +"agents@npm:^0.0.100": + version: 0.0.100 + resolution: "agents@npm:0.0.100" + dependencies: + "@modelcontextprotocol/sdk": "npm:^1.13.1" + ai: "npm:^4.3.16" + cron-schedule: "npm:^5.0.4" + nanoid: "npm:^5.1.5" + partyserver: "npm:^0.0.72" + partysocket: "npm:1.1.4" + zod: "npm:^3.25.67" + peerDependencies: + react: "*" + checksum: 10c0/8b8238fade413b1ad10a2543bdac9558ef9df565503c9e6b1050942527e2b696f66c165cfe81b857add5b57fd13793689771df06a8d2cb9e7195f82d07d0457d + languageName: node + linkType: hard + +"ai@npm:^4.3.16": + version: 4.3.19 + resolution: "ai@npm:4.3.19" + dependencies: + "@ai-sdk/provider": "npm:1.1.3" + "@ai-sdk/provider-utils": "npm:2.2.8" + "@ai-sdk/react": "npm:1.2.12" + "@ai-sdk/ui-utils": "npm:1.2.11" + "@opentelemetry/api": "npm:1.9.0" + jsondiffpatch: "npm:0.6.0" + peerDependencies: + react: ^18 || ^19 || ^19.0.0-rc + zod: ^3.23.8 + peerDependenciesMeta: + react: + optional: true + checksum: 10c0/738ac453b3e61b2f2282941fe8af946c42696fbdcffa5ac213823377bcddf475f26923cf2ca5656d5655e5c351e355e1af62dcb04a6df6139b67bac650b01af2 + languageName: node + linkType: hard + +"ajv@npm:^6.12.6": + version: 6.12.6 + resolution: "ajv@npm:6.12.6" + dependencies: + fast-deep-equal: "npm:^3.1.1" + fast-json-stable-stringify: "npm:^2.0.0" + json-schema-traverse: "npm:^0.4.1" + uri-js: "npm:^4.2.2" + checksum: 10c0/41e23642cbe545889245b9d2a45854ebba51cda6c778ebced9649420d9205f2efb39cb43dbc41e358409223b1ea43303ae4839db682c848b891e4811da1a5a71 + languageName: node + linkType: hard + +"ansi-regex@npm:^5.0.1": + version: 5.0.1 + resolution: "ansi-regex@npm:5.0.1" + checksum: 10c0/9a64bb8627b434ba9327b60c027742e5d17ac69277960d041898596271d992d4d52ba7267a63ca10232e29f6107fc8a835f6ce8d719b88c5f8493f8254813737 + languageName: node + linkType: hard + +"ansi-regex@npm:^6.0.1": + version: 6.1.0 + resolution: "ansi-regex@npm:6.1.0" + checksum: 10c0/a91daeddd54746338478eef88af3439a7edf30f8e23196e2d6ed182da9add559c601266dbef01c2efa46a958ad6f1f8b176799657616c702b5b02e799e7fd8dc + languageName: node + linkType: hard + +"ansi-styles@npm:^4.0.0": + version: 4.3.0 + resolution: "ansi-styles@npm:4.3.0" + dependencies: + color-convert: "npm:^2.0.1" + checksum: 10c0/895a23929da416f2bd3de7e9cb4eabd340949328ab85ddd6e484a637d8f6820d485f53933446f5291c3b760cbc488beb8e88573dd0f9c7daf83dccc8fe81b041 + languageName: node + linkType: hard + +"ansi-styles@npm:^6.1.0": + version: 6.2.1 + resolution: "ansi-styles@npm:6.2.1" + checksum: 10c0/5d1ec38c123984bcedd996eac680d548f31828bd679a66db2bdf11844634dde55fec3efa9c6bb1d89056a5e79c1ac540c4c784d592ea1d25028a92227d2f2d5c + languageName: node + linkType: hard + +"balanced-match@npm:^1.0.0": + version: 1.0.2 + resolution: "balanced-match@npm:1.0.2" + checksum: 10c0/9308baf0a7e4838a82bbfd11e01b1cb0f0cf2893bc1676c27c2a8c0e70cbae1c59120c3268517a8ae7fb6376b4639ef81ca22582611dbee4ed28df945134aaee + languageName: node + linkType: hard + +"blake3-wasm@npm:2.1.5": + version: 2.1.5 + resolution: "blake3-wasm@npm:2.1.5" + checksum: 10c0/5dc729d8e3a9d1d7ab016b36cdda264a327ada0239716df48435163e11d2bf6df25d6e421655a1f52649098ae49555268a654729b7d02768f77c571ab37ef814 + languageName: node + linkType: hard + +"body-parser@npm:^2.2.0": + version: 2.2.0 + resolution: "body-parser@npm:2.2.0" + dependencies: + bytes: "npm:^3.1.2" + content-type: "npm:^1.0.5" + debug: "npm:^4.4.0" + http-errors: "npm:^2.0.0" + iconv-lite: "npm:^0.6.3" + on-finished: "npm:^2.4.1" + qs: "npm:^6.14.0" + raw-body: "npm:^3.0.0" + type-is: "npm:^2.0.0" + checksum: 10c0/a9ded39e71ac9668e2211afa72e82ff86cc5ef94de1250b7d1ba9cc299e4150408aaa5f1e8b03dd4578472a3ce6d1caa2a23b27a6c18e526e48b4595174c116c + languageName: node + linkType: hard + +"brace-expansion@npm:^2.0.1": + version: 2.0.2 + resolution: "brace-expansion@npm:2.0.2" + dependencies: + balanced-match: "npm:^1.0.0" + checksum: 10c0/6d117a4c793488af86b83172deb6af143e94c17bc53b0b3cec259733923b4ca84679d506ac261f4ba3c7ed37c46018e2ff442f9ce453af8643ecd64f4a54e6cf + languageName: node + linkType: hard + +"bytes@npm:3.1.2, bytes@npm:^3.1.2": + version: 3.1.2 + resolution: "bytes@npm:3.1.2" + checksum: 10c0/76d1c43cbd602794ad8ad2ae94095cddeb1de78c5dddaa7005c51af10b0176c69971a6d88e805a90c2b6550d76636e43c40d8427a808b8645ede885de4a0358e + languageName: node + linkType: hard + +"cacache@npm:^19.0.1": + version: 19.0.1 + resolution: "cacache@npm:19.0.1" + dependencies: + "@npmcli/fs": "npm:^4.0.0" + fs-minipass: "npm:^3.0.0" + glob: "npm:^10.2.2" + lru-cache: "npm:^10.0.1" + minipass: "npm:^7.0.3" + minipass-collect: "npm:^2.0.1" + minipass-flush: "npm:^1.0.5" + minipass-pipeline: "npm:^1.2.4" + p-map: "npm:^7.0.2" + ssri: "npm:^12.0.0" + tar: "npm:^7.4.3" + unique-filename: "npm:^4.0.0" + checksum: 10c0/01f2134e1bd7d3ab68be851df96c8d63b492b1853b67f2eecb2c37bb682d37cb70bb858a16f2f0554d3c0071be6dfe21456a1ff6fa4b7eed996570d6a25ffe9c + languageName: node + linkType: hard + +"call-bind-apply-helpers@npm:^1.0.1, call-bind-apply-helpers@npm:^1.0.2": + version: 1.0.2 + resolution: "call-bind-apply-helpers@npm:1.0.2" + dependencies: + es-errors: "npm:^1.3.0" + function-bind: "npm:^1.1.2" + checksum: 10c0/47bd9901d57b857590431243fea704ff18078b16890a6b3e021e12d279bbf211d039155e27d7566b374d49ee1f8189344bac9833dec7a20cdec370506361c938 + languageName: node + linkType: hard + +"call-bound@npm:^1.0.2": + version: 1.0.4 + resolution: "call-bound@npm:1.0.4" + dependencies: + call-bind-apply-helpers: "npm:^1.0.2" + get-intrinsic: "npm:^1.3.0" + checksum: 10c0/f4796a6a0941e71c766aea672f63b72bc61234c4f4964dc6d7606e3664c307e7d77845328a8f3359ce39ddb377fed67318f9ee203dea1d47e46165dcf2917644 + languageName: node + linkType: hard + +"chalk@npm:^5.3.0": + version: 5.4.1 + resolution: "chalk@npm:5.4.1" + checksum: 10c0/b23e88132c702f4855ca6d25cb5538b1114343e41472d5263ee8a37cccfccd9c4216d111e1097c6a27830407a1dc81fecdf2a56f2c63033d4dbbd88c10b0dcef + languageName: node + linkType: hard + +"chownr@npm:^3.0.0": + version: 3.0.0 + resolution: "chownr@npm:3.0.0" + checksum: 10c0/43925b87700f7e3893296c8e9c56cc58f926411cce3a6e5898136daaf08f08b9a8eb76d37d3267e707d0dcc17aed2e2ebdf5848c0c3ce95cf910a919935c1b10 + languageName: node + linkType: hard + +"color-convert@npm:^2.0.1": + version: 2.0.1 + resolution: "color-convert@npm:2.0.1" + dependencies: + color-name: "npm:~1.1.4" + checksum: 10c0/37e1150172f2e311fe1b2df62c6293a342ee7380da7b9cfdba67ea539909afbd74da27033208d01d6d5cfc65ee7868a22e18d7e7648e004425441c0f8a15a7d7 + languageName: node + linkType: hard + +"color-name@npm:^1.0.0, color-name@npm:~1.1.4": + version: 1.1.4 + resolution: "color-name@npm:1.1.4" + checksum: 10c0/a1a3f914156960902f46f7f56bc62effc6c94e84b2cae157a526b1c1f74b677a47ec602bf68a61abfa2b42d15b7c5651c6dbe72a43af720bc588dff885b10f95 + languageName: node + linkType: hard + +"color-string@npm:^1.9.0": + version: 1.9.1 + resolution: "color-string@npm:1.9.1" + dependencies: + color-name: "npm:^1.0.0" + simple-swizzle: "npm:^0.2.2" + checksum: 10c0/b0bfd74c03b1f837f543898b512f5ea353f71630ccdd0d66f83028d1f0924a7d4272deb278b9aef376cacf1289b522ac3fb175e99895283645a2dc3a33af2404 + languageName: node + linkType: hard + +"color@npm:^4.2.3": + version: 4.2.3 + resolution: "color@npm:4.2.3" + dependencies: + color-convert: "npm:^2.0.1" + color-string: "npm:^1.9.0" + checksum: 10c0/7fbe7cfb811054c808349de19fb380252e5e34e61d7d168ec3353e9e9aacb1802674bddc657682e4e9730c2786592a4de6f8283e7e0d3870b829bb0b7b2f6118 + languageName: node + linkType: hard + +"content-disposition@npm:^1.0.0": + version: 1.0.0 + resolution: "content-disposition@npm:1.0.0" + dependencies: + safe-buffer: "npm:5.2.1" + checksum: 10c0/c7b1ba0cea2829da0352ebc1b7f14787c73884bc707c8bc2271d9e3bf447b372270d09f5d3980dc5037c749ceef56b9a13fccd0b0001c87c3f12579967e4dd27 + languageName: node + linkType: hard + +"content-type@npm:^1.0.5": + version: 1.0.5 + resolution: "content-type@npm:1.0.5" + checksum: 10c0/b76ebed15c000aee4678c3707e0860cb6abd4e680a598c0a26e17f0bfae723ec9cc2802f0ff1bc6e4d80603719010431d2231018373d4dde10f9ccff9dadf5af + languageName: node + linkType: hard + +"cookie-signature@npm:^1.2.1": + version: 1.2.2 + resolution: "cookie-signature@npm:1.2.2" + checksum: 10c0/54e05df1a293b3ce81589b27dddc445f462f6fa6812147c033350cd3561a42bc14481674e05ed14c7bd0ce1e8bb3dc0e40851bad75415733711294ddce0b7bc6 + languageName: node + linkType: hard + +"cookie@npm:^0.7.1": + version: 0.7.2 + resolution: "cookie@npm:0.7.2" + checksum: 10c0/9596e8ccdbf1a3a88ae02cf5ee80c1c50959423e1022e4e60b91dd87c622af1da309253d8abdb258fb5e3eacb4f08e579dc58b4897b8087574eee0fd35dfa5d2 + languageName: node + linkType: hard + +"cookie@npm:^1.0.2": + version: 1.0.2 + resolution: "cookie@npm:1.0.2" + checksum: 10c0/fd25fe79e8fbcfcaf6aa61cd081c55d144eeeba755206c058682257cb38c4bd6795c6620de3f064c740695bb65b7949ebb1db7a95e4636efb8357a335ad3f54b + languageName: node + linkType: hard + +"cors@npm:^2.8.5": + version: 2.8.5 + resolution: "cors@npm:2.8.5" + dependencies: + object-assign: "npm:^4" + vary: "npm:^1" + checksum: 10c0/373702b7999409922da80de4a61938aabba6929aea5b6fd9096fefb9e8342f626c0ebd7507b0e8b0b311380744cc985f27edebc0a26e0ddb784b54e1085de761 + languageName: node + linkType: hard + +"cron-schedule@npm:^5.0.4": + version: 5.0.4 + resolution: "cron-schedule@npm:5.0.4" + checksum: 10c0/8b89b4a4b90dff66e277855012d6b4b4ee18f2d3d16f74aa40e9555a0c08b2d4bc4ba8c7526cf6213490f32099f8a3a0db86942b7dbfbb1d2580cccf0ba344ae + languageName: node + linkType: hard + +"cross-spawn@npm:^7.0.5, cross-spawn@npm:^7.0.6": + version: 7.0.6 + resolution: "cross-spawn@npm:7.0.6" + dependencies: + path-key: "npm:^3.1.0" + shebang-command: "npm:^2.0.0" + which: "npm:^2.0.1" + checksum: 10c0/053ea8b2135caff68a9e81470e845613e374e7309a47731e81639de3eaeb90c3d01af0e0b44d2ab9d50b43467223b88567dfeb3262db942dc063b9976718ffc1 + languageName: node + linkType: hard + +"debug@npm:4, debug@npm:^4.3.4, debug@npm:^4.3.5, debug@npm:^4.4.0": + version: 4.4.1 + resolution: "debug@npm:4.4.1" + dependencies: + ms: "npm:^2.1.3" + peerDependenciesMeta: + supports-color: + optional: true + checksum: 10c0/d2b44bc1afd912b49bb7ebb0d50a860dc93a4dd7d946e8de94abc957bb63726b7dd5aa48c18c2386c379ec024c46692e15ed3ed97d481729f929201e671fcd55 + languageName: node + linkType: hard + +"defu@npm:^6.1.4": + version: 6.1.4 + resolution: "defu@npm:6.1.4" + checksum: 10c0/2d6cc366262dc0cb8096e429368e44052fdf43ed48e53ad84cc7c9407f890301aa5fcb80d0995abaaf842b3949f154d060be4160f7a46cb2bc2f7726c81526f5 + languageName: node + linkType: hard + +"depd@npm:2.0.0, depd@npm:^2.0.0": + version: 2.0.0 + resolution: "depd@npm:2.0.0" + checksum: 10c0/58bd06ec20e19529b06f7ad07ddab60e504d9e0faca4bd23079fac2d279c3594334d736508dc350e06e510aba5e22e4594483b3a6562ce7c17dd797f4cc4ad2c + languageName: node + linkType: hard + +"dequal@npm:^2.0.3": + version: 2.0.3 + resolution: "dequal@npm:2.0.3" + checksum: 10c0/f98860cdf58b64991ae10205137c0e97d384c3a4edc7f807603887b7c4b850af1224a33d88012009f150861cbee4fa2d322c4cc04b9313bee312e47f6ecaa888 + languageName: node + linkType: hard + +"detect-libc@npm:^2.0.3": + version: 2.0.4 + resolution: "detect-libc@npm:2.0.4" + checksum: 10c0/c15541f836eba4b1f521e4eecc28eefefdbc10a94d3b8cb4c507689f332cc111babb95deda66f2de050b22122113189986d5190be97d51b5a2b23b938415e67c + languageName: node + linkType: hard + +"diff-match-patch@npm:^1.0.5": + version: 1.0.5 + resolution: "diff-match-patch@npm:1.0.5" + checksum: 10c0/142b6fad627b9ef309d11bd935e82b84c814165a02500f046e2773f4ea894d10ed3017ac20454900d79d4a0322079f5b713cf0986aaf15fce0ec4a2479980c86 + languageName: node + linkType: hard + +"dunder-proto@npm:^1.0.1": + version: 1.0.1 + resolution: "dunder-proto@npm:1.0.1" + dependencies: + call-bind-apply-helpers: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + gopd: "npm:^1.2.0" + checksum: 10c0/199f2a0c1c16593ca0a145dbf76a962f8033ce3129f01284d48c45ed4e14fea9bbacd7b3610b6cdc33486cef20385ac054948fefc6272fcce645c09468f93031 + languageName: node + linkType: hard + +"eastasianwidth@npm:^0.2.0": + version: 0.2.0 + resolution: "eastasianwidth@npm:0.2.0" + checksum: 10c0/26f364ebcdb6395f95124fda411f63137a4bfb5d3a06453f7f23dfe52502905bd84e0488172e0f9ec295fdc45f05c23d5d91baf16bd26f0fe9acd777a188dc39 + languageName: node + linkType: hard + +"ee-first@npm:1.1.1": + version: 1.1.1 + resolution: "ee-first@npm:1.1.1" + checksum: 10c0/b5bb125ee93161bc16bfe6e56c6b04de5ad2aa44234d8f644813cc95d861a6910903132b05093706de2b706599367c4130eb6d170f6b46895686b95f87d017b7 + languageName: node + linkType: hard + +"emoji-regex@npm:^8.0.0": + version: 8.0.0 + resolution: "emoji-regex@npm:8.0.0" + checksum: 10c0/b6053ad39951c4cf338f9092d7bfba448cdfd46fe6a2a034700b149ac9ffbc137e361cbd3c442297f86bed2e5f7576c1b54cc0a6bf8ef5106cc62f496af35010 + languageName: node + linkType: hard + +"emoji-regex@npm:^9.2.2": + version: 9.2.2 + resolution: "emoji-regex@npm:9.2.2" + checksum: 10c0/af014e759a72064cf66e6e694a7fc6b0ed3d8db680427b021a89727689671cefe9d04151b2cad51dbaf85d5ba790d061cd167f1cf32eb7b281f6368b3c181639 + languageName: node + linkType: hard + +"encodeurl@npm:^2.0.0": + version: 2.0.0 + resolution: "encodeurl@npm:2.0.0" + checksum: 10c0/5d317306acb13e6590e28e27924c754163946a2480de11865c991a3a7eed4315cd3fba378b543ca145829569eefe9b899f3d84bb09870f675ae60bc924b01ceb + languageName: node + linkType: hard + +"encoding@npm:^0.1.13": + version: 0.1.13 + resolution: "encoding@npm:0.1.13" + dependencies: + iconv-lite: "npm:^0.6.2" + checksum: 10c0/36d938712ff00fe1f4bac88b43bcffb5930c1efa57bbcdca9d67e1d9d6c57cfb1200fb01efe0f3109b2ce99b231f90779532814a81370a1bd3274a0f58585039 + languageName: node + linkType: hard + +"env-paths@npm:^2.2.0": + version: 2.2.1 + resolution: "env-paths@npm:2.2.1" + checksum: 10c0/285325677bf00e30845e330eec32894f5105529db97496ee3f598478e50f008c5352a41a30e5e72ec9de8a542b5a570b85699cd63bd2bc646dbcb9f311d83bc4 + languageName: node + linkType: hard + +"err-code@npm:^2.0.2": + version: 2.0.3 + resolution: "err-code@npm:2.0.3" + checksum: 10c0/b642f7b4dd4a376e954947550a3065a9ece6733ab8e51ad80db727aaae0817c2e99b02a97a3d6cecc648a97848305e728289cf312d09af395403a90c9d4d8a66 + languageName: node + linkType: hard + +"error-stack-parser-es@npm:^1.0.5": + version: 1.0.5 + resolution: "error-stack-parser-es@npm:1.0.5" + checksum: 10c0/040665eb87a42fe068c0da501bc258f3d15d3a03963c0723d7a2741e251d400c9776a52d2803afdc5709def99554cdb5a5d99c203c7eaf4885d3fbc217e2e8f7 + languageName: node + linkType: hard + +"es-define-property@npm:^1.0.1": + version: 1.0.1 + resolution: "es-define-property@npm:1.0.1" + checksum: 10c0/3f54eb49c16c18707949ff25a1456728c883e81259f045003499efba399c08bad00deebf65cccde8c0e07908c1a225c9d472b7107e558f2a48e28d530e34527c + languageName: node + linkType: hard + +"es-errors@npm:^1.3.0": + version: 1.3.0 + resolution: "es-errors@npm:1.3.0" + checksum: 10c0/0a61325670072f98d8ae3b914edab3559b6caa980f08054a3b872052640d91da01d38df55df797fcc916389d77fc92b8d5906cf028f4db46d7e3003abecbca85 + languageName: node + linkType: hard + +"es-object-atoms@npm:^1.0.0, es-object-atoms@npm:^1.1.1": + version: 1.1.1 + resolution: "es-object-atoms@npm:1.1.1" + dependencies: + es-errors: "npm:^1.3.0" + checksum: 10c0/65364812ca4daf48eb76e2a3b7a89b3f6a2e62a1c420766ce9f692665a29d94fe41fe88b65f24106f449859549711e4b40d9fb8002d862dfd7eb1c512d10be0c + languageName: node + linkType: hard + +"esbuild@npm:0.25.4": + version: 0.25.4 + resolution: "esbuild@npm:0.25.4" + dependencies: + "@esbuild/aix-ppc64": "npm:0.25.4" + "@esbuild/android-arm": "npm:0.25.4" + "@esbuild/android-arm64": "npm:0.25.4" + "@esbuild/android-x64": "npm:0.25.4" + "@esbuild/darwin-arm64": "npm:0.25.4" + "@esbuild/darwin-x64": "npm:0.25.4" + "@esbuild/freebsd-arm64": "npm:0.25.4" + "@esbuild/freebsd-x64": "npm:0.25.4" + "@esbuild/linux-arm": "npm:0.25.4" + "@esbuild/linux-arm64": "npm:0.25.4" + "@esbuild/linux-ia32": "npm:0.25.4" + "@esbuild/linux-loong64": "npm:0.25.4" + "@esbuild/linux-mips64el": "npm:0.25.4" + "@esbuild/linux-ppc64": "npm:0.25.4" + "@esbuild/linux-riscv64": "npm:0.25.4" + "@esbuild/linux-s390x": "npm:0.25.4" + "@esbuild/linux-x64": "npm:0.25.4" + "@esbuild/netbsd-arm64": "npm:0.25.4" + "@esbuild/netbsd-x64": "npm:0.25.4" + "@esbuild/openbsd-arm64": "npm:0.25.4" + "@esbuild/openbsd-x64": "npm:0.25.4" + "@esbuild/sunos-x64": "npm:0.25.4" + "@esbuild/win32-arm64": "npm:0.25.4" + "@esbuild/win32-ia32": "npm:0.25.4" + "@esbuild/win32-x64": "npm:0.25.4" + dependenciesMeta: + "@esbuild/aix-ppc64": + optional: true + "@esbuild/android-arm": + optional: true + "@esbuild/android-arm64": + optional: true + "@esbuild/android-x64": + optional: true + "@esbuild/darwin-arm64": + optional: true + "@esbuild/darwin-x64": + optional: true + "@esbuild/freebsd-arm64": + optional: true + "@esbuild/freebsd-x64": + optional: true + "@esbuild/linux-arm": + optional: true + "@esbuild/linux-arm64": + optional: true + "@esbuild/linux-ia32": + optional: true + "@esbuild/linux-loong64": + optional: true + "@esbuild/linux-mips64el": + optional: true + "@esbuild/linux-ppc64": + optional: true + "@esbuild/linux-riscv64": + optional: true + "@esbuild/linux-s390x": + optional: true + "@esbuild/linux-x64": + optional: true + "@esbuild/netbsd-arm64": + optional: true + "@esbuild/netbsd-x64": + optional: true + "@esbuild/openbsd-arm64": + optional: true + "@esbuild/openbsd-x64": + optional: true + "@esbuild/sunos-x64": + optional: true + "@esbuild/win32-arm64": + optional: true + "@esbuild/win32-ia32": + optional: true + "@esbuild/win32-x64": + optional: true + bin: + esbuild: bin/esbuild + checksum: 10c0/db9f51248f0560bc46ab219461d338047617f6caf373c95f643b204760bdfa10c95b48cfde948949f7e509599ae4ab61c3f112092a3534936c6abfb800c565b0 + languageName: node + linkType: hard + +"escape-html@npm:^1.0.3": + version: 1.0.3 + resolution: "escape-html@npm:1.0.3" + checksum: 10c0/524c739d776b36c3d29fa08a22e03e8824e3b2fd57500e5e44ecf3cc4707c34c60f9ca0781c0e33d191f2991161504c295e98f68c78fe7baa6e57081ec6ac0a3 + languageName: node + linkType: hard + +"etag@npm:^1.8.1": + version: 1.8.1 + resolution: "etag@npm:1.8.1" + checksum: 10c0/12be11ef62fb9817314d790089a0a49fae4e1b50594135dcb8076312b7d7e470884b5100d249b28c18581b7fd52f8b485689ffae22a11ed9ec17377a33a08f84 + languageName: node + linkType: hard + +"event-target-polyfill@npm:^0.0.4": + version: 0.0.4 + resolution: "event-target-polyfill@npm:0.0.4" + checksum: 10c0/7052b838df6509e8290f110daf94604dd05828834db4ad6fe4a12abc693da1a3274100cfd4ff3e47a941d5aa3fb7cdb8164d85402b93d85340bb3adc596d8732 + languageName: node + linkType: hard + +"eventsource-parser@npm:^3.0.0, eventsource-parser@npm:^3.0.1": + version: 3.0.3 + resolution: "eventsource-parser@npm:3.0.3" + checksum: 10c0/2594011630efba56cafafc8ed6bd9a50db8f6d5dd62089b0950346e7961828c16efe07a588bdea3ba79e568fd9246c8163824a2ffaade767e1fdb2270c1fae0b + languageName: node + linkType: hard + +"eventsource@npm:^3.0.2": + version: 3.0.7 + resolution: "eventsource@npm:3.0.7" + dependencies: + eventsource-parser: "npm:^3.0.1" + checksum: 10c0/c48a73c38f300e33e9f11375d4ee969f25cbb0519608a12378a38068055ae8b55b6e0e8a49c3f91c784068434efe1d9f01eb49b6315b04b0da9157879ce2f67d + languageName: node + linkType: hard + +"exit-hook@npm:2.2.1": + version: 2.2.1 + resolution: "exit-hook@npm:2.2.1" + checksum: 10c0/0803726d1b60aade6afd10c73e5a7e1bf256ac9bee78362a88e91a4f735e8c67899f2853ddc613072c05af07bbb067a9978a740e614db1aeef167d50c6dc5c09 + languageName: node + linkType: hard + +"exponential-backoff@npm:^3.1.1": + version: 3.1.2 + resolution: "exponential-backoff@npm:3.1.2" + checksum: 10c0/d9d3e1eafa21b78464297df91f1776f7fbaa3d5e3f7f0995648ca5b89c069d17055033817348d9f4a43d1c20b0eab84f75af6991751e839df53e4dfd6f22e844 + languageName: node + linkType: hard + +"express-rate-limit@npm:^7.5.0": + version: 7.5.1 + resolution: "express-rate-limit@npm:7.5.1" + peerDependencies: + express: ">= 4.11" + checksum: 10c0/b07de84d700a2c07c4bf2f040e7558ed5a1f660f03ed5f30bf8ff7b51e98ba7a85215640e70fc48cbbb9151066ea51239d9a1b41febc9b84d98c7915b0186161 + languageName: node + linkType: hard + +"express@npm:^5.0.1": + version: 5.1.0 + resolution: "express@npm:5.1.0" + dependencies: + accepts: "npm:^2.0.0" + body-parser: "npm:^2.2.0" + content-disposition: "npm:^1.0.0" + content-type: "npm:^1.0.5" + cookie: "npm:^0.7.1" + cookie-signature: "npm:^1.2.1" + debug: "npm:^4.4.0" + encodeurl: "npm:^2.0.0" + escape-html: "npm:^1.0.3" + etag: "npm:^1.8.1" + finalhandler: "npm:^2.1.0" + fresh: "npm:^2.0.0" + http-errors: "npm:^2.0.0" + merge-descriptors: "npm:^2.0.0" + mime-types: "npm:^3.0.0" + on-finished: "npm:^2.4.1" + once: "npm:^1.4.0" + parseurl: "npm:^1.3.3" + proxy-addr: "npm:^2.0.7" + qs: "npm:^6.14.0" + range-parser: "npm:^1.2.1" + router: "npm:^2.2.0" + send: "npm:^1.1.0" + serve-static: "npm:^2.2.0" + statuses: "npm:^2.0.1" + type-is: "npm:^2.0.1" + vary: "npm:^1.1.2" + checksum: 10c0/80ce7c53c5f56887d759b94c3f2283e2e51066c98d4b72a4cc1338e832b77f1e54f30d0239cc10815a0f849bdb753e6a284d2fa48d4ab56faf9c501f55d751d6 + languageName: node + linkType: hard + +"exsolve@npm:^1.0.4": + version: 1.0.7 + resolution: "exsolve@npm:1.0.7" + checksum: 10c0/4479369d0bd84bb7e0b4f5d9bc18d26a89b6dbbbccd73f9d383d14892ef78ddbe159e01781055342f83dc00ebe90044036daf17ddf55cc21e2cac6609aa15631 + languageName: node + linkType: hard + +"fast-deep-equal@npm:^3.1.1": + version: 3.1.3 + resolution: "fast-deep-equal@npm:3.1.3" + checksum: 10c0/40dedc862eb8992c54579c66d914635afbec43350afbbe991235fdcb4e3a8d5af1b23ae7e79bef7d4882d0ecee06c3197488026998fb19f72dc95acff1d1b1d0 + languageName: node + linkType: hard + +"fast-json-stable-stringify@npm:^2.0.0": + version: 2.1.0 + resolution: "fast-json-stable-stringify@npm:2.1.0" + checksum: 10c0/7f081eb0b8a64e0057b3bb03f974b3ef00135fbf36c1c710895cd9300f13c94ba809bb3a81cf4e1b03f6e5285610a61abbd7602d0652de423144dfee5a389c9b + languageName: node + linkType: hard + +"fdir@npm:^6.4.4": + version: 6.4.6 + resolution: "fdir@npm:6.4.6" + peerDependencies: + picomatch: ^3 || ^4 + peerDependenciesMeta: + picomatch: + optional: true + checksum: 10c0/45b559cff889934ebb8bc498351e5acba40750ada7e7d6bde197768d2fa67c149be8ae7f8ff34d03f4e1eb20f2764116e56440aaa2f6689e9a4aa7ef06acafe9 + languageName: node + linkType: hard + +"finalhandler@npm:^2.1.0": + version: 2.1.0 + resolution: "finalhandler@npm:2.1.0" + dependencies: + debug: "npm:^4.4.0" + encodeurl: "npm:^2.0.0" + escape-html: "npm:^1.0.3" + on-finished: "npm:^2.4.1" + parseurl: "npm:^1.3.3" + statuses: "npm:^2.0.1" + checksum: 10c0/da0bbca6d03873472ee890564eb2183f4ed377f25f3628a0fc9d16dac40bed7b150a0d82ebb77356e4c6d97d2796ad2dba22948b951dddee2c8768b0d1b9fb1f + languageName: node + linkType: hard + +"foreground-child@npm:^3.1.0": + version: 3.3.1 + resolution: "foreground-child@npm:3.3.1" + dependencies: + cross-spawn: "npm:^7.0.6" + signal-exit: "npm:^4.0.1" + checksum: 10c0/8986e4af2430896e65bc2788d6679067294d6aee9545daefc84923a0a4b399ad9c7a3ea7bd8c0b2b80fdf4a92de4c69df3f628233ff3224260e9c1541a9e9ed3 + languageName: node + linkType: hard + +"forwarded@npm:0.2.0": + version: 0.2.0 + resolution: "forwarded@npm:0.2.0" + checksum: 10c0/9b67c3fac86acdbc9ae47ba1ddd5f2f81526fa4c8226863ede5600a3f7c7416ef451f6f1e240a3cc32d0fd79fcfe6beb08fd0da454f360032bde70bf80afbb33 + languageName: node + linkType: hard + +"fresh@npm:^2.0.0": + version: 2.0.0 + resolution: "fresh@npm:2.0.0" + checksum: 10c0/0557548194cb9a809a435bf92bcfbc20c89e8b5eb38861b73ced36750437251e39a111fc3a18b98531be9dd91fe1411e4969f229dc579ec0251ce6c5d4900bbc + languageName: node + linkType: hard + +"fs-minipass@npm:^3.0.0": + version: 3.0.3 + resolution: "fs-minipass@npm:3.0.3" + dependencies: + minipass: "npm:^7.0.3" + checksum: 10c0/63e80da2ff9b621e2cb1596abcb9207f1cf82b968b116ccd7b959e3323144cce7fb141462200971c38bbf2ecca51695069db45265705bed09a7cd93ae5b89f94 + languageName: node + linkType: hard + +"fsevents@npm:~2.3.2": + version: 2.3.3 + resolution: "fsevents@npm:2.3.3" + dependencies: + node-gyp: "npm:latest" + checksum: 10c0/a1f0c44595123ed717febbc478aa952e47adfc28e2092be66b8ab1635147254ca6cfe1df792a8997f22716d4cbafc73309899ff7bfac2ac3ad8cf2e4ecc3ec60 + conditions: os=darwin + languageName: node + linkType: hard + +"fsevents@patch:fsevents@npm%3A~2.3.2#optional!builtin": + version: 2.3.3 + resolution: "fsevents@patch:fsevents@npm%3A2.3.3#optional!builtin::version=2.3.3&hash=df0bf1" + dependencies: + node-gyp: "npm:latest" + conditions: os=darwin + languageName: node + linkType: hard + +"function-bind@npm:^1.1.2": + version: 1.1.2 + resolution: "function-bind@npm:1.1.2" + checksum: 10c0/d8680ee1e5fcd4c197e4ac33b2b4dce03c71f4d91717292785703db200f5c21f977c568d28061226f9b5900cbcd2c84463646134fd5337e7925e0942bc3f46d5 + languageName: node + linkType: hard + +"get-intrinsic@npm:^1.2.5, get-intrinsic@npm:^1.3.0": + version: 1.3.0 + resolution: "get-intrinsic@npm:1.3.0" + dependencies: + call-bind-apply-helpers: "npm:^1.0.2" + es-define-property: "npm:^1.0.1" + es-errors: "npm:^1.3.0" + es-object-atoms: "npm:^1.1.1" + function-bind: "npm:^1.1.2" + get-proto: "npm:^1.0.1" + gopd: "npm:^1.2.0" + has-symbols: "npm:^1.1.0" + hasown: "npm:^2.0.2" + math-intrinsics: "npm:^1.1.0" + checksum: 10c0/52c81808af9a8130f581e6a6a83e1ba4a9f703359e7a438d1369a5267a25412322f03dcbd7c549edaef0b6214a0630a28511d7df0130c93cfd380f4fa0b5b66a + languageName: node + linkType: hard + +"get-proto@npm:^1.0.1": + version: 1.0.1 + resolution: "get-proto@npm:1.0.1" + dependencies: + dunder-proto: "npm:^1.0.1" + es-object-atoms: "npm:^1.0.0" + checksum: 10c0/9224acb44603c5526955e83510b9da41baf6ae73f7398875fba50edc5e944223a89c4a72b070fcd78beb5f7bdda58ecb6294adc28f7acfc0da05f76a2399643c + languageName: node + linkType: hard + +"glob-to-regexp@npm:0.4.1": + version: 0.4.1 + resolution: "glob-to-regexp@npm:0.4.1" + checksum: 10c0/0486925072d7a916f052842772b61c3e86247f0a80cc0deb9b5a3e8a1a9faad5b04fb6f58986a09f34d3e96cd2a22a24b7e9882fb1cf904c31e9a310de96c429 + languageName: node + linkType: hard + +"glob@npm:^10.2.2": + version: 10.4.5 + resolution: "glob@npm:10.4.5" + dependencies: + foreground-child: "npm:^3.1.0" + jackspeak: "npm:^3.1.2" + minimatch: "npm:^9.0.4" + minipass: "npm:^7.1.2" + package-json-from-dist: "npm:^1.0.0" + path-scurry: "npm:^1.11.1" + bin: + glob: dist/esm/bin.mjs + checksum: 10c0/19a9759ea77b8e3ca0a43c2f07ecddc2ad46216b786bb8f993c445aee80d345925a21e5280c7b7c6c59e860a0154b84e4b2b60321fea92cd3c56b4a7489f160e + languageName: node + linkType: hard + +"gopd@npm:^1.2.0": + version: 1.2.0 + resolution: "gopd@npm:1.2.0" + checksum: 10c0/50fff1e04ba2b7737c097358534eacadad1e68d24cccee3272e04e007bed008e68d2614f3987788428fd192a5ae3889d08fb2331417e4fc4a9ab366b2043cead + languageName: node + linkType: hard + +"graceful-fs@npm:^4.2.6": + version: 4.2.11 + resolution: "graceful-fs@npm:4.2.11" + checksum: 10c0/386d011a553e02bc594ac2ca0bd6d9e4c22d7fa8cfbfc448a6d148c59ea881b092db9dbe3547ae4b88e55f1b01f7c4a2ecc53b310c042793e63aa44cf6c257f2 + languageName: node + linkType: hard + +"has-symbols@npm:^1.1.0": + version: 1.1.0 + resolution: "has-symbols@npm:1.1.0" + checksum: 10c0/dde0a734b17ae51e84b10986e651c664379018d10b91b6b0e9b293eddb32f0f069688c841fb40f19e9611546130153e0a2a48fd7f512891fb000ddfa36f5a20e + languageName: node + linkType: hard + +"hasown@npm:^2.0.2": + version: 2.0.2 + resolution: "hasown@npm:2.0.2" + dependencies: + function-bind: "npm:^1.1.2" + checksum: 10c0/3769d434703b8ac66b209a4cca0737519925bbdb61dd887f93a16372b14694c63ff4e797686d87c90f08168e81082248b9b028bad60d4da9e0d1148766f56eb9 + languageName: node + linkType: hard + +"hono@npm:^4.8.4": + version: 4.8.9 + resolution: "hono@npm:4.8.9" + checksum: 10c0/385539d1787fdc747bc869ef0e5ccc9f39cbe40289b94f23eecfc82c6ca440f059704647cd6381a5066d2cf7baa43ab25184c78d44af4c5c98a5c5b07670059e + languageName: node + linkType: hard + +"http-cache-semantics@npm:^4.1.1": + version: 4.2.0 + resolution: "http-cache-semantics@npm:4.2.0" + checksum: 10c0/45b66a945cf13ec2d1f29432277201313babf4a01d9e52f44b31ca923434083afeca03f18417f599c9ab3d0e7b618ceb21257542338b57c54b710463b4a53e37 + languageName: node + linkType: hard + +"http-errors@npm:2.0.0, http-errors@npm:^2.0.0": + version: 2.0.0 + resolution: "http-errors@npm:2.0.0" + dependencies: + depd: "npm:2.0.0" + inherits: "npm:2.0.4" + setprototypeof: "npm:1.2.0" + statuses: "npm:2.0.1" + toidentifier: "npm:1.0.1" + checksum: 10c0/fc6f2715fe188d091274b5ffc8b3657bd85c63e969daa68ccb77afb05b071a4b62841acb7a21e417b5539014dff2ebf9550f0b14a9ff126f2734a7c1387f8e19 + languageName: node + linkType: hard + +"http-proxy-agent@npm:^7.0.0": + version: 7.0.2 + resolution: "http-proxy-agent@npm:7.0.2" + dependencies: + agent-base: "npm:^7.1.0" + debug: "npm:^4.3.4" + checksum: 10c0/4207b06a4580fb85dd6dff521f0abf6db517489e70863dca1a0291daa7f2d3d2d6015a57bd702af068ea5cf9f1f6ff72314f5f5b4228d299c0904135d2aef921 + languageName: node + linkType: hard + +"https-proxy-agent@npm:^7.0.1": + version: 7.0.6 + resolution: "https-proxy-agent@npm:7.0.6" + dependencies: + agent-base: "npm:^7.1.2" + debug: "npm:4" + checksum: 10c0/f729219bc735edb621fa30e6e84e60ee5d00802b8247aac0d7b79b0bd6d4b3294737a337b93b86a0bd9e68099d031858a39260c976dc14cdbba238ba1f8779ac + languageName: node + linkType: hard + +"iconv-lite@npm:0.6.3, iconv-lite@npm:^0.6.2, iconv-lite@npm:^0.6.3": + version: 0.6.3 + resolution: "iconv-lite@npm:0.6.3" + dependencies: + safer-buffer: "npm:>= 2.1.2 < 3.0.0" + checksum: 10c0/98102bc66b33fcf5ac044099d1257ba0b7ad5e3ccd3221f34dd508ab4070edff183276221684e1e0555b145fce0850c9f7d2b60a9fcac50fbb4ea0d6e845a3b1 + languageName: node + linkType: hard + +"imurmurhash@npm:^0.1.4": + version: 0.1.4 + resolution: "imurmurhash@npm:0.1.4" + checksum: 10c0/8b51313850dd33605c6c9d3fd9638b714f4c4c40250cff658209f30d40da60f78992fb2df5dabee4acf589a6a82bbc79ad5486550754bd9ec4e3fc0d4a57d6a6 + languageName: node + linkType: hard + +"inherits@npm:2.0.4": + version: 2.0.4 + resolution: "inherits@npm:2.0.4" + checksum: 10c0/4e531f648b29039fb7426fb94075e6545faa1eb9fe83c29f0b6d9e7263aceb4289d2d4557db0d428188eeb449cc7c5e77b0a0b2c4e248ff2a65933a0dee49ef2 + languageName: node + linkType: hard + +"ip-address@npm:^9.0.5": + version: 9.0.5 + resolution: "ip-address@npm:9.0.5" + dependencies: + jsbn: "npm:1.1.0" + sprintf-js: "npm:^1.1.3" + checksum: 10c0/331cd07fafcb3b24100613e4b53e1a2b4feab11e671e655d46dc09ee233da5011284d09ca40c4ecbdfe1d0004f462958675c224a804259f2f78d2465a87824bc + languageName: node + linkType: hard + +"ipaddr.js@npm:1.9.1": + version: 1.9.1 + resolution: "ipaddr.js@npm:1.9.1" + checksum: 10c0/0486e775047971d3fdb5fb4f063829bac45af299ae0b82dcf3afa2145338e08290563a2a70f34b732d795ecc8311902e541a8530eeb30d75860a78ff4e94ce2a + languageName: node + linkType: hard + +"is-arrayish@npm:^0.3.1": + version: 0.3.2 + resolution: "is-arrayish@npm:0.3.2" + checksum: 10c0/f59b43dc1d129edb6f0e282595e56477f98c40278a2acdc8b0a5c57097c9eff8fe55470493df5775478cf32a4dc8eaf6d3a749f07ceee5bc263a78b2434f6a54 + languageName: node + linkType: hard + +"is-fullwidth-code-point@npm:^3.0.0": + version: 3.0.0 + resolution: "is-fullwidth-code-point@npm:3.0.0" + checksum: 10c0/bb11d825e049f38e04c06373a8d72782eee0205bda9d908cc550ccb3c59b99d750ff9537982e01733c1c94a58e35400661f57042158ff5e8f3e90cf936daf0fc + languageName: node + linkType: hard + +"is-promise@npm:^4.0.0": + version: 4.0.0 + resolution: "is-promise@npm:4.0.0" + checksum: 10c0/ebd5c672d73db781ab33ccb155fb9969d6028e37414d609b115cc534654c91ccd061821d5b987eefaa97cf4c62f0b909bb2f04db88306de26e91bfe8ddc01503 + languageName: node + linkType: hard + +"isexe@npm:^2.0.0": + version: 2.0.0 + resolution: "isexe@npm:2.0.0" + checksum: 10c0/228cfa503fadc2c31596ab06ed6aa82c9976eec2bfd83397e7eaf06d0ccf42cd1dfd6743bf9aeb01aebd4156d009994c5f76ea898d2832c1fe342da923ca457d + languageName: node + linkType: hard + +"isexe@npm:^3.1.1": + version: 3.1.1 + resolution: "isexe@npm:3.1.1" + checksum: 10c0/9ec257654093443eb0a528a9c8cbba9c0ca7616ccb40abd6dde7202734d96bb86e4ac0d764f0f8cd965856aacbff2f4ce23e730dc19dfb41e3b0d865ca6fdcc7 + languageName: node + linkType: hard + +"jackspeak@npm:^3.1.2": + version: 3.4.3 + resolution: "jackspeak@npm:3.4.3" + dependencies: + "@isaacs/cliui": "npm:^8.0.2" + "@pkgjs/parseargs": "npm:^0.11.0" + dependenciesMeta: + "@pkgjs/parseargs": + optional: true + checksum: 10c0/6acc10d139eaefdbe04d2f679e6191b3abf073f111edf10b1de5302c97ec93fffeb2fdd8681ed17f16268aa9dd4f8c588ed9d1d3bffbbfa6e8bf897cbb3149b9 + languageName: node + linkType: hard + +"jose@npm:^6.0.11": + version: 6.0.12 + resolution: "jose@npm:6.0.12" + checksum: 10c0/e5ca51b078b2443f6ca671e14d72e0ffd21b760dac0d77cabd7af649a127376ec90665c8b25f34dd88bb31094915ee662daf76e0b33a025d28dbc2bc17413dec + languageName: node + linkType: hard + +"jsbn@npm:1.1.0": + version: 1.1.0 + resolution: "jsbn@npm:1.1.0" + checksum: 10c0/4f907fb78d7b712e11dea8c165fe0921f81a657d3443dde75359ed52eb2b5d33ce6773d97985a089f09a65edd80b11cb75c767b57ba47391fee4c969f7215c96 + languageName: node + linkType: hard + +"json-schema-traverse@npm:^0.4.1": + version: 0.4.1 + resolution: "json-schema-traverse@npm:0.4.1" + checksum: 10c0/108fa90d4cc6f08243aedc6da16c408daf81793bf903e9fd5ab21983cda433d5d2da49e40711da016289465ec2e62e0324dcdfbc06275a607fe3233fde4942ce + languageName: node + linkType: hard + +"json-schema@npm:^0.4.0": + version: 0.4.0 + resolution: "json-schema@npm:0.4.0" + checksum: 10c0/d4a637ec1d83544857c1c163232f3da46912e971d5bf054ba44fdb88f07d8d359a462b4aec46f2745efbc57053365608d88bc1d7b1729f7b4fc3369765639ed3 + languageName: node + linkType: hard + +"jsondiffpatch@npm:0.6.0": + version: 0.6.0 + resolution: "jsondiffpatch@npm:0.6.0" + dependencies: + "@types/diff-match-patch": "npm:^1.0.36" + chalk: "npm:^5.3.0" + diff-match-patch: "npm:^1.0.5" + bin: + jsondiffpatch: bin/jsondiffpatch.js + checksum: 10c0/f7822e48a8ef8b9f7c6024cc59b7d3707a9fe6d84fd776d169de5a1803ad551ffe7cfdc7587f3900f224bc70897355884ed43eb1c8ccd02e7f7b43a7ebcfed4f + languageName: node + linkType: hard + +"kleur@npm:^4.1.5": + version: 4.1.5 + resolution: "kleur@npm:4.1.5" + checksum: 10c0/e9de6cb49657b6fa70ba2d1448fd3d691a5c4370d8f7bbf1c2f64c24d461270f2117e1b0afe8cb3114f13bbd8e51de158c2a224953960331904e636a5e4c0f2a + languageName: node + linkType: hard + +"lru-cache@npm:^10.0.1, lru-cache@npm:^10.2.0": + version: 10.4.3 + resolution: "lru-cache@npm:10.4.3" + checksum: 10c0/ebd04fbca961e6c1d6c0af3799adcc966a1babe798f685bb84e6599266599cd95d94630b10262f5424539bc4640107e8a33aa28585374abf561d30d16f4b39fb + languageName: node + linkType: hard + +"make-fetch-happen@npm:^14.0.3": + version: 14.0.3 + resolution: "make-fetch-happen@npm:14.0.3" + dependencies: + "@npmcli/agent": "npm:^3.0.0" + cacache: "npm:^19.0.1" + http-cache-semantics: "npm:^4.1.1" + minipass: "npm:^7.0.2" + minipass-fetch: "npm:^4.0.0" + minipass-flush: "npm:^1.0.5" + minipass-pipeline: "npm:^1.2.4" + negotiator: "npm:^1.0.0" + proc-log: "npm:^5.0.0" + promise-retry: "npm:^2.0.1" + ssri: "npm:^12.0.0" + checksum: 10c0/c40efb5e5296e7feb8e37155bde8eb70bc57d731b1f7d90e35a092fde403d7697c56fb49334d92d330d6f1ca29a98142036d6480a12681133a0a1453164cb2f0 + languageName: node + linkType: hard + +"math-intrinsics@npm:^1.1.0": + version: 1.1.0 + resolution: "math-intrinsics@npm:1.1.0" + checksum: 10c0/7579ff94e899e2f76ab64491d76cf606274c874d8f2af4a442c016bd85688927fcfca157ba6bf74b08e9439dc010b248ce05b96cc7c126a354c3bae7fcb48b7f + languageName: node + linkType: hard + +"media-typer@npm:^1.1.0": + version: 1.1.0 + resolution: "media-typer@npm:1.1.0" + checksum: 10c0/7b4baa40b25964bb90e2121ee489ec38642127e48d0cc2b6baa442688d3fde6262bfdca86d6bbf6ba708784afcac168c06840c71facac70e390f5f759ac121b9 + languageName: node + linkType: hard + +"merge-descriptors@npm:^2.0.0": + version: 2.0.0 + resolution: "merge-descriptors@npm:2.0.0" + checksum: 10c0/95389b7ced3f9b36fbdcf32eb946dc3dd1774c2fdf164609e55b18d03aa499b12bd3aae3a76c1c7185b96279e9803525550d3eb292b5224866060a288f335cb3 + languageName: node + linkType: hard + +"mime-db@npm:^1.54.0": + version: 1.54.0 + resolution: "mime-db@npm:1.54.0" + checksum: 10c0/8d907917bc2a90fa2df842cdf5dfeaf509adc15fe0531e07bb2f6ab15992416479015828d6a74200041c492e42cce3ebf78e5ce714388a0a538ea9c53eece284 + languageName: node + linkType: hard + +"mime-types@npm:^3.0.0, mime-types@npm:^3.0.1": + version: 3.0.1 + resolution: "mime-types@npm:3.0.1" + dependencies: + mime-db: "npm:^1.54.0" + checksum: 10c0/bd8c20d3694548089cf229016124f8f40e6a60bbb600161ae13e45f793a2d5bb40f96bbc61f275836696179c77c1d6bf4967b2a75e0a8ad40fe31f4ed5be4da5 + languageName: node + linkType: hard + +"mime@npm:^3.0.0": + version: 3.0.0 + resolution: "mime@npm:3.0.0" + bin: + mime: cli.js + checksum: 10c0/402e792a8df1b2cc41cb77f0dcc46472b7944b7ec29cb5bbcd398624b6b97096728f1239766d3fdeb20551dd8d94738344c195a6ea10c4f906eb0356323b0531 + languageName: node + linkType: hard + +"miniflare@npm:4.20250712.2": + version: 4.20250712.2 + resolution: "miniflare@npm:4.20250712.2" + dependencies: + "@cspotcode/source-map-support": "npm:0.8.1" + acorn: "npm:8.14.0" + acorn-walk: "npm:8.3.2" + exit-hook: "npm:2.2.1" + glob-to-regexp: "npm:0.4.1" + sharp: "npm:^0.33.5" + stoppable: "npm:1.1.0" + undici: "npm:^7.10.0" + workerd: "npm:1.20250712.0" + ws: "npm:8.18.0" + youch: "npm:4.1.0-beta.10" + zod: "npm:3.22.3" + bin: + miniflare: bootstrap.js + checksum: 10c0/0cc64db60d82523e5a565163a9c147f0435300e5946a5e82197a55e56872b3d47adeb2dfd37fbbdf4ca8d251fc290b3765462a5fea17b8858dd22679359d56f8 + languageName: node + linkType: hard + +"minimatch@npm:^9.0.4": + version: 9.0.5 + resolution: "minimatch@npm:9.0.5" + dependencies: + brace-expansion: "npm:^2.0.1" + checksum: 10c0/de96cf5e35bdf0eab3e2c853522f98ffbe9a36c37797778d2665231ec1f20a9447a7e567cb640901f89e4daaa95ae5d70c65a9e8aa2bb0019b6facbc3c0575ed + languageName: node + linkType: hard + +"minipass-collect@npm:^2.0.1": + version: 2.0.1 + resolution: "minipass-collect@npm:2.0.1" + dependencies: + minipass: "npm:^7.0.3" + checksum: 10c0/5167e73f62bb74cc5019594709c77e6a742051a647fe9499abf03c71dca75515b7959d67a764bdc4f8b361cf897fbf25e2d9869ee039203ed45240f48b9aa06e + languageName: node + linkType: hard + +"minipass-fetch@npm:^4.0.0": + version: 4.0.1 + resolution: "minipass-fetch@npm:4.0.1" + dependencies: + encoding: "npm:^0.1.13" + minipass: "npm:^7.0.3" + minipass-sized: "npm:^1.0.3" + minizlib: "npm:^3.0.1" + dependenciesMeta: + encoding: + optional: true + checksum: 10c0/a3147b2efe8e078c9bf9d024a0059339c5a09c5b1dded6900a219c218cc8b1b78510b62dae556b507304af226b18c3f1aeb1d48660283602d5b6586c399eed5c + languageName: node + linkType: hard + +"minipass-flush@npm:^1.0.5": + version: 1.0.5 + resolution: "minipass-flush@npm:1.0.5" + dependencies: + minipass: "npm:^3.0.0" + checksum: 10c0/2a51b63feb799d2bb34669205eee7c0eaf9dce01883261a5b77410c9408aa447e478efd191b4de6fc1101e796ff5892f8443ef20d9544385819093dbb32d36bd + languageName: node + linkType: hard + +"minipass-pipeline@npm:^1.2.4": + version: 1.2.4 + resolution: "minipass-pipeline@npm:1.2.4" + dependencies: + minipass: "npm:^3.0.0" + checksum: 10c0/cbda57cea20b140b797505dc2cac71581a70b3247b84480c1fed5ca5ba46c25ecc25f68bfc9e6dcb1a6e9017dab5c7ada5eab73ad4f0a49d84e35093e0c643f2 + languageName: node + linkType: hard + +"minipass-sized@npm:^1.0.3": + version: 1.0.3 + resolution: "minipass-sized@npm:1.0.3" + dependencies: + minipass: "npm:^3.0.0" + checksum: 10c0/298f124753efdc745cfe0f2bdfdd81ba25b9f4e753ca4a2066eb17c821f25d48acea607dfc997633ee5bf7b6dfffb4eee4f2051eb168663f0b99fad2fa4829cb + languageName: node + linkType: hard + +"minipass@npm:^3.0.0": + version: 3.3.6 + resolution: "minipass@npm:3.3.6" + dependencies: + yallist: "npm:^4.0.0" + checksum: 10c0/a114746943afa1dbbca8249e706d1d38b85ed1298b530f5808ce51f8e9e941962e2a5ad2e00eae7dd21d8a4aae6586a66d4216d1a259385e9d0358f0c1eba16c + languageName: node + linkType: hard + +"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3, minipass@npm:^7.0.4, minipass@npm:^7.1.2": + version: 7.1.2 + resolution: "minipass@npm:7.1.2" + checksum: 10c0/b0fd20bb9fb56e5fa9a8bfac539e8915ae07430a619e4b86ff71f5fc757ef3924b23b2c4230393af1eda647ed3d75739e4e0acb250a6b1eb277cf7f8fe449557 + languageName: node + linkType: hard + +"minizlib@npm:^3.0.1": + version: 3.0.2 + resolution: "minizlib@npm:3.0.2" + dependencies: + minipass: "npm:^7.1.2" + checksum: 10c0/9f3bd35e41d40d02469cb30470c55ccc21cae0db40e08d1d0b1dff01cc8cc89a6f78e9c5d2b7c844e485ec0a8abc2238111213fdc5b2038e6d1012eacf316f78 + languageName: node + linkType: hard + +"mkdirp@npm:^3.0.1": + version: 3.0.1 + resolution: "mkdirp@npm:3.0.1" + bin: + mkdirp: dist/cjs/src/bin.js + checksum: 10c0/9f2b975e9246351f5e3a40dcfac99fcd0baa31fbfab615fe059fb11e51f10e4803c63de1f384c54d656e4db31d000e4767e9ef076a22e12a641357602e31d57d + languageName: node + linkType: hard + +"ms@npm:^2.1.3": + version: 2.1.3 + resolution: "ms@npm:2.1.3" + checksum: 10c0/d924b57e7312b3b63ad21fc5b3dc0af5e78d61a1fc7cfb5457edaf26326bf62be5307cc87ffb6862ef1c2b33b0233cdb5d4f01c4c958cc0d660948b65a287a48 + languageName: node + linkType: hard + +"nanoid@npm:^3.3.8": + version: 3.3.11 + resolution: "nanoid@npm:3.3.11" + bin: + nanoid: bin/nanoid.cjs + checksum: 10c0/40e7f70b3d15f725ca072dfc4f74e81fcf1fbb02e491cf58ac0c79093adc9b0a73b152bcde57df4b79cd097e13023d7504acb38404a4da7bc1cd8e887b82fe0b + languageName: node + linkType: hard + +"nanoid@npm:^5.1.5": + version: 5.1.5 + resolution: "nanoid@npm:5.1.5" + bin: + nanoid: bin/nanoid.js + checksum: 10c0/e6004f1ad6c7123eeb037062c4441d44982037dc043aabb162457ef6986e99964ba98c63c975f96c547403beb0bf95bc537bd7bf9a09baf381656acdc2975c3c + languageName: node + linkType: hard + +"negotiator@npm:^1.0.0": + version: 1.0.0 + resolution: "negotiator@npm:1.0.0" + checksum: 10c0/4c559dd52669ea48e1914f9d634227c561221dd54734070791f999c52ed0ff36e437b2e07d5c1f6e32909fc625fe46491c16e4a8f0572567d4dd15c3a4fda04b + languageName: node + linkType: hard + +"node-gyp@npm:latest": + version: 11.2.0 + resolution: "node-gyp@npm:11.2.0" + dependencies: + env-paths: "npm:^2.2.0" + exponential-backoff: "npm:^3.1.1" + graceful-fs: "npm:^4.2.6" + make-fetch-happen: "npm:^14.0.3" + nopt: "npm:^8.0.0" + proc-log: "npm:^5.0.0" + semver: "npm:^7.3.5" + tar: "npm:^7.4.3" + tinyglobby: "npm:^0.2.12" + which: "npm:^5.0.0" + bin: + node-gyp: bin/node-gyp.js + checksum: 10c0/bd8d8c76b06be761239b0c8680f655f6a6e90b48e44d43415b11c16f7e8c15be346fba0cbf71588c7cdfb52c419d928a7d3db353afc1d952d19756237d8f10b9 + languageName: node + linkType: hard + +"nopt@npm:^8.0.0": + version: 8.1.0 + resolution: "nopt@npm:8.1.0" + dependencies: + abbrev: "npm:^3.0.0" + bin: + nopt: bin/nopt.js + checksum: 10c0/62e9ea70c7a3eb91d162d2c706b6606c041e4e7b547cbbb48f8b3695af457dd6479904d7ace600856bf923dd8d1ed0696f06195c8c20f02ac87c1da0e1d315ef + languageName: node + linkType: hard + +"oauth4webapi@npm:^3.5.5": + version: 3.6.0 + resolution: "oauth4webapi@npm:3.6.0" + checksum: 10c0/5bfad39628db80faa563b3da4cae342a99827399e7b8730469ece452ecab84e32951b17c09f5904125f0ba6f2f869c01c354421d29470bc90940d8c6c226eef2 + languageName: node + linkType: hard + +"object-assign@npm:^4": + version: 4.1.1 + resolution: "object-assign@npm:4.1.1" + checksum: 10c0/1f4df9945120325d041ccf7b86f31e8bcc14e73d29171e37a7903050e96b81323784ec59f93f102ec635bcf6fa8034ba3ea0a8c7e69fa202b87ae3b6cec5a414 + languageName: node + linkType: hard + +"object-inspect@npm:^1.13.3": + version: 1.13.4 + resolution: "object-inspect@npm:1.13.4" + checksum: 10c0/d7f8711e803b96ea3191c745d6f8056ce1f2496e530e6a19a0e92d89b0fa3c76d910c31f0aa270432db6bd3b2f85500a376a83aaba849a8d518c8845b3211692 + languageName: node + linkType: hard + +"ohash@npm:^2.0.11": + version: 2.0.11 + resolution: "ohash@npm:2.0.11" + checksum: 10c0/d07c8d79cc26da082c1a7c8d5b56c399dd4ed3b2bd069fcae6bae78c99a9bcc3ad813b1e1f49ca2f335292846d689c6141a762cf078727d2302a33d414e69c79 + languageName: node + linkType: hard + +"on-finished@npm:^2.4.1": + version: 2.4.1 + resolution: "on-finished@npm:2.4.1" + dependencies: + ee-first: "npm:1.1.1" + checksum: 10c0/46fb11b9063782f2d9968863d9cbba33d77aa13c17f895f56129c274318b86500b22af3a160fe9995aa41317efcd22941b6eba747f718ced08d9a73afdb087b4 + languageName: node + linkType: hard + +"once@npm:^1.4.0": + version: 1.4.0 + resolution: "once@npm:1.4.0" + dependencies: + wrappy: "npm:1" + checksum: 10c0/5d48aca287dfefabd756621c5dfce5c91a549a93e9fdb7b8246bc4c4790aa2ec17b34a260530474635147aeb631a2dcc8b32c613df0675f96041cbb8244517d0 + languageName: node + linkType: hard + +"p-map@npm:^7.0.2": + version: 7.0.3 + resolution: "p-map@npm:7.0.3" + checksum: 10c0/46091610da2b38ce47bcd1d8b4835a6fa4e832848a6682cf1652bc93915770f4617afc844c10a77d1b3e56d2472bb2d5622353fa3ead01a7f42b04fc8e744a5c + languageName: node + linkType: hard + +"package-json-from-dist@npm:^1.0.0": + version: 1.0.1 + resolution: "package-json-from-dist@npm:1.0.1" + checksum: 10c0/62ba2785eb655fec084a257af34dbe24292ab74516d6aecef97ef72d4897310bc6898f6c85b5cd22770eaa1ce60d55a0230e150fb6a966e3ecd6c511e23d164b + languageName: node + linkType: hard + +"parseurl@npm:^1.3.3": + version: 1.3.3 + resolution: "parseurl@npm:1.3.3" + checksum: 10c0/90dd4760d6f6174adb9f20cf0965ae12e23879b5f5464f38e92fce8073354341e4b3b76fa3d878351efe7d01e617121955284cfd002ab087fba1a0726ec0b4f5 + languageName: node + linkType: hard + +"partyserver@npm:^0.0.72": + version: 0.0.72 + resolution: "partyserver@npm:0.0.72" + dependencies: + nanoid: "npm:^5.1.5" + peerDependencies: + "@cloudflare/workers-types": ^4.20240729.0 + checksum: 10c0/94075ecb2f11a1517f32916fbc662b542735ade7e092042f9f9888d61ebb1d3cfd76ccaf406ff8e7c672c6812123fb075888c6b4196c7d38df10dbdc8f0d928a + languageName: node + linkType: hard + +"partysocket@npm:1.1.4": + version: 1.1.4 + resolution: "partysocket@npm:1.1.4" + dependencies: + event-target-polyfill: "npm:^0.0.4" + checksum: 10c0/d859bcaef5f5e8be0f383140a896a41e78c95fc2166002d2a60f09168c720d78864e8f8e3251ed5146d46bf9487102dd9c81d34893c811bfc8ea64f7236f2fed + languageName: node + linkType: hard + +"path-key@npm:^3.1.0": + version: 3.1.1 + resolution: "path-key@npm:3.1.1" + checksum: 10c0/748c43efd5a569c039d7a00a03b58eecd1d75f3999f5a28303d75f521288df4823bc057d8784eb72358b2895a05f29a070bc9f1f17d28226cc4e62494cc58c4c + languageName: node + linkType: hard + +"path-scurry@npm:^1.11.1": + version: 1.11.1 + resolution: "path-scurry@npm:1.11.1" + dependencies: + lru-cache: "npm:^10.2.0" + minipass: "npm:^5.0.0 || ^6.0.2 || ^7.0.0" + checksum: 10c0/32a13711a2a505616ae1cc1b5076801e453e7aae6ac40ab55b388bb91b9d0547a52f5aaceff710ea400205f18691120d4431e520afbe4266b836fadede15872d + languageName: node + linkType: hard + +"path-to-regexp@npm:6.3.0": + version: 6.3.0 + resolution: "path-to-regexp@npm:6.3.0" + checksum: 10c0/73b67f4638b41cde56254e6354e46ae3a2ebc08279583f6af3d96fe4664fc75788f74ed0d18ca44fa4a98491b69434f9eee73b97bb5314bd1b5adb700f5c18d6 + languageName: node + linkType: hard + +"path-to-regexp@npm:^8.0.0": + version: 8.2.0 + resolution: "path-to-regexp@npm:8.2.0" + checksum: 10c0/ef7d0a887b603c0a142fad16ccebdcdc42910f0b14830517c724466ad676107476bba2fe9fffd28fd4c141391ccd42ea426f32bb44c2c82ecaefe10c37b90f5a + languageName: node + linkType: hard + +"pathe@npm:^2.0.3": + version: 2.0.3 + resolution: "pathe@npm:2.0.3" + checksum: 10c0/c118dc5a8b5c4166011b2b70608762e260085180bb9e33e80a50dcdb1e78c010b1624f4280c492c92b05fc276715a4c357d1f9edc570f8f1b3d90b6839ebaca1 + languageName: node + linkType: hard + +"picomatch@npm:^4.0.2": + version: 4.0.3 + resolution: "picomatch@npm:4.0.3" + checksum: 10c0/9582c951e95eebee5434f59e426cddd228a7b97a0161a375aed4be244bd3fe8e3a31b846808ea14ef2c8a2527a6eeab7b3946a67d5979e81694654f939473ae2 + languageName: node + linkType: hard + +"pkce-challenge@npm:^5.0.0": + version: 5.0.0 + resolution: "pkce-challenge@npm:5.0.0" + checksum: 10c0/c6706d627fdbb6f22bf8cc5d60d96d6b6a7bb481399b336a3d3f4e9bfba3e167a2c32f8ec0b5e74be686a0ba3bcc9894865d4c2dd1b91cea4c05dba1f28602c3 + languageName: node + linkType: hard + +"proc-log@npm:^5.0.0": + version: 5.0.0 + resolution: "proc-log@npm:5.0.0" + checksum: 10c0/bbe5edb944b0ad63387a1d5b1911ae93e05ce8d0f60de1035b218cdcceedfe39dbd2c697853355b70f1a090f8f58fe90da487c85216bf9671f9499d1a897e9e3 + languageName: node + linkType: hard + +"promise-retry@npm:^2.0.1": + version: 2.0.1 + resolution: "promise-retry@npm:2.0.1" + dependencies: + err-code: "npm:^2.0.2" + retry: "npm:^0.12.0" + checksum: 10c0/9c7045a1a2928094b5b9b15336dcd2a7b1c052f674550df63cc3f36cd44028e5080448175b6f6ca32b642de81150f5e7b1a98b728f15cb069f2dd60ac2616b96 + languageName: node + linkType: hard + +"proxy-addr@npm:^2.0.7": + version: 2.0.7 + resolution: "proxy-addr@npm:2.0.7" + dependencies: + forwarded: "npm:0.2.0" + ipaddr.js: "npm:1.9.1" + checksum: 10c0/c3eed999781a35f7fd935f398b6d8920b6fb00bbc14287bc6de78128ccc1a02c89b95b56742bf7cf0362cc333c61d138532049c7dedc7a328ef13343eff81210 + languageName: node + linkType: hard + +"punycode@npm:^2.1.0": + version: 2.3.1 + resolution: "punycode@npm:2.3.1" + checksum: 10c0/14f76a8206bc3464f794fb2e3d3cc665ae416c01893ad7a02b23766eb07159144ee612ad67af5e84fa4479ccfe67678c4feb126b0485651b302babf66f04f9e9 + languageName: node + linkType: hard + +"qs@npm:^6.14.0": + version: 6.14.0 + resolution: "qs@npm:6.14.0" + dependencies: + side-channel: "npm:^1.1.0" + checksum: 10c0/8ea5d91bf34f440598ee389d4a7d95820e3b837d3fd9f433871f7924801becaa0cd3b3b4628d49a7784d06a8aea9bc4554d2b6d8d584e2d221dc06238a42909c + languageName: node + linkType: hard + +"range-parser@npm:^1.2.1": + version: 1.2.1 + resolution: "range-parser@npm:1.2.1" + checksum: 10c0/96c032ac2475c8027b7a4e9fe22dc0dfe0f6d90b85e496e0f016fbdb99d6d066de0112e680805075bd989905e2123b3b3d002765149294dce0c1f7f01fcc2ea0 + languageName: node + linkType: hard + +"raw-body@npm:^3.0.0": + version: 3.0.0 + resolution: "raw-body@npm:3.0.0" + dependencies: + bytes: "npm:3.1.2" + http-errors: "npm:2.0.0" + iconv-lite: "npm:0.6.3" + unpipe: "npm:1.0.0" + checksum: 10c0/f8daf4b724064a4811d118745a781ca0fb4676298b8adadfd6591155549cfea0a067523cf7dd3baeb1265fecc9ce5dfb2fc788c12c66b85202a336593ece0f87 + languageName: node + linkType: hard + +"retry@npm:^0.12.0": + version: 0.12.0 + resolution: "retry@npm:0.12.0" + checksum: 10c0/59933e8501727ba13ad73ef4a04d5280b3717fd650408460c987392efe9d7be2040778ed8ebe933c5cbd63da3dcc37919c141ef8af0a54a6e4fca5a2af177bfe + languageName: node + linkType: hard + +"router@npm:^2.2.0": + version: 2.2.0 + resolution: "router@npm:2.2.0" + dependencies: + debug: "npm:^4.4.0" + depd: "npm:^2.0.0" + is-promise: "npm:^4.0.0" + parseurl: "npm:^1.3.3" + path-to-regexp: "npm:^8.0.0" + checksum: 10c0/3279de7450c8eae2f6e095e9edacbdeec0abb5cb7249c6e719faa0db2dba43574b4fff5892d9220631c9abaff52dd3cad648cfea2aaace845e1a071915ac8867 + languageName: node + linkType: hard + +"safe-buffer@npm:5.2.1": + version: 5.2.1 + resolution: "safe-buffer@npm:5.2.1" + checksum: 10c0/6501914237c0a86e9675d4e51d89ca3c21ffd6a31642efeba25ad65720bce6921c9e7e974e5be91a786b25aa058b5303285d3c15dbabf983a919f5f630d349f3 + languageName: node + linkType: hard + +"safer-buffer@npm:>= 2.1.2 < 3.0.0": + version: 2.1.2 + resolution: "safer-buffer@npm:2.1.2" + checksum: 10c0/7e3c8b2e88a1841c9671094bbaeebd94448111dd90a81a1f606f3f67708a6ec57763b3b47f06da09fc6054193e0e6709e77325415dc8422b04497a8070fa02d4 + languageName: node + linkType: hard + +"secure-json-parse@npm:^2.7.0": + version: 2.7.0 + resolution: "secure-json-parse@npm:2.7.0" + checksum: 10c0/f57eb6a44a38a3eeaf3548228585d769d788f59007454214fab9ed7f01fbf2e0f1929111da6db28cf0bcc1a2e89db5219a59e83eeaec3a54e413a0197ce879e4 + languageName: node + linkType: hard + +"semver@npm:^7.3.5, semver@npm:^7.6.3": + version: 7.7.2 + resolution: "semver@npm:7.7.2" + bin: + semver: bin/semver.js + checksum: 10c0/aca305edfbf2383c22571cb7714f48cadc7ac95371b4b52362fb8eeffdfbc0de0669368b82b2b15978f8848f01d7114da65697e56cd8c37b0dab8c58e543f9ea + languageName: node + linkType: hard + +"send@npm:^1.1.0, send@npm:^1.2.0": + version: 1.2.0 + resolution: "send@npm:1.2.0" + dependencies: + debug: "npm:^4.3.5" + encodeurl: "npm:^2.0.0" + escape-html: "npm:^1.0.3" + etag: "npm:^1.8.1" + fresh: "npm:^2.0.0" + http-errors: "npm:^2.0.0" + mime-types: "npm:^3.0.1" + ms: "npm:^2.1.3" + on-finished: "npm:^2.4.1" + range-parser: "npm:^1.2.1" + statuses: "npm:^2.0.1" + checksum: 10c0/531bcfb5616948d3468d95a1fd0adaeb0c20818ba4a500f439b800ca2117971489e02074ce32796fd64a6772ea3e7235fe0583d8241dbd37a053dc3378eff9a5 + languageName: node + linkType: hard + +"serve-static@npm:^2.2.0": + version: 2.2.0 + resolution: "serve-static@npm:2.2.0" + dependencies: + encodeurl: "npm:^2.0.0" + escape-html: "npm:^1.0.3" + parseurl: "npm:^1.3.3" + send: "npm:^1.2.0" + checksum: 10c0/30e2ed1dbff1984836cfd0c65abf5d3f3f83bcd696c99d2d3c97edbd4e2a3ff4d3f87108a7d713640d290a7b6fe6c15ddcbc61165ab2eaad48ea8d3b52c7f913 + languageName: node + linkType: hard + +"setprototypeof@npm:1.2.0": + version: 1.2.0 + resolution: "setprototypeof@npm:1.2.0" + checksum: 10c0/68733173026766fa0d9ecaeb07f0483f4c2dc70ca376b3b7c40b7cda909f94b0918f6c5ad5ce27a9160bdfb475efaa9d5e705a11d8eaae18f9835d20976028bc + languageName: node + linkType: hard + +"sharp@npm:^0.33.5": + version: 0.33.5 + resolution: "sharp@npm:0.33.5" + dependencies: + "@img/sharp-darwin-arm64": "npm:0.33.5" + "@img/sharp-darwin-x64": "npm:0.33.5" + "@img/sharp-libvips-darwin-arm64": "npm:1.0.4" + "@img/sharp-libvips-darwin-x64": "npm:1.0.4" + "@img/sharp-libvips-linux-arm": "npm:1.0.5" + "@img/sharp-libvips-linux-arm64": "npm:1.0.4" + "@img/sharp-libvips-linux-s390x": "npm:1.0.4" + "@img/sharp-libvips-linux-x64": "npm:1.0.4" + "@img/sharp-libvips-linuxmusl-arm64": "npm:1.0.4" + "@img/sharp-libvips-linuxmusl-x64": "npm:1.0.4" + "@img/sharp-linux-arm": "npm:0.33.5" + "@img/sharp-linux-arm64": "npm:0.33.5" + "@img/sharp-linux-s390x": "npm:0.33.5" + "@img/sharp-linux-x64": "npm:0.33.5" + "@img/sharp-linuxmusl-arm64": "npm:0.33.5" + "@img/sharp-linuxmusl-x64": "npm:0.33.5" + "@img/sharp-wasm32": "npm:0.33.5" + "@img/sharp-win32-ia32": "npm:0.33.5" + "@img/sharp-win32-x64": "npm:0.33.5" + color: "npm:^4.2.3" + detect-libc: "npm:^2.0.3" + semver: "npm:^7.6.3" + dependenciesMeta: + "@img/sharp-darwin-arm64": + optional: true + "@img/sharp-darwin-x64": + optional: true + "@img/sharp-libvips-darwin-arm64": + optional: true + "@img/sharp-libvips-darwin-x64": + optional: true + "@img/sharp-libvips-linux-arm": + optional: true + "@img/sharp-libvips-linux-arm64": + optional: true + "@img/sharp-libvips-linux-s390x": + optional: true + "@img/sharp-libvips-linux-x64": + optional: true + "@img/sharp-libvips-linuxmusl-arm64": + optional: true + "@img/sharp-libvips-linuxmusl-x64": + optional: true + "@img/sharp-linux-arm": + optional: true + "@img/sharp-linux-arm64": + optional: true + "@img/sharp-linux-s390x": + optional: true + "@img/sharp-linux-x64": + optional: true + "@img/sharp-linuxmusl-arm64": + optional: true + "@img/sharp-linuxmusl-x64": + optional: true + "@img/sharp-wasm32": + optional: true + "@img/sharp-win32-ia32": + optional: true + "@img/sharp-win32-x64": + optional: true + checksum: 10c0/6b81421ddfe6ee524d8d77e325c5e147fef22884e1c7b1656dfd89a88d7025894115da02d5f984261bf2e6daa16f98cadd1721c4ba408b4212b1d2a60f233484 + languageName: node + linkType: hard + +"shebang-command@npm:^2.0.0": + version: 2.0.0 + resolution: "shebang-command@npm:2.0.0" + dependencies: + shebang-regex: "npm:^3.0.0" + checksum: 10c0/a41692e7d89a553ef21d324a5cceb5f686d1f3c040759c50aab69688634688c5c327f26f3ecf7001ebfd78c01f3c7c0a11a7c8bfd0a8bc9f6240d4f40b224e4e + languageName: node + linkType: hard + +"shebang-regex@npm:^3.0.0": + version: 3.0.0 + resolution: "shebang-regex@npm:3.0.0" + checksum: 10c0/1dbed0726dd0e1152a92696c76c7f06084eb32a90f0528d11acd764043aacf76994b2fb30aa1291a21bd019d6699164d048286309a278855ee7bec06cf6fb690 + languageName: node + linkType: hard + +"side-channel-list@npm:^1.0.0": + version: 1.0.0 + resolution: "side-channel-list@npm:1.0.0" + dependencies: + es-errors: "npm:^1.3.0" + object-inspect: "npm:^1.13.3" + checksum: 10c0/644f4ac893456c9490ff388bf78aea9d333d5e5bfc64cfb84be8f04bf31ddc111a8d4b83b85d7e7e8a7b845bc185a9ad02c052d20e086983cf59f0be517d9b3d + languageName: node + linkType: hard + +"side-channel-map@npm:^1.0.1": + version: 1.0.1 + resolution: "side-channel-map@npm:1.0.1" + dependencies: + call-bound: "npm:^1.0.2" + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.5" + object-inspect: "npm:^1.13.3" + checksum: 10c0/010584e6444dd8a20b85bc926d934424bd809e1a3af941cace229f7fdcb751aada0fb7164f60c2e22292b7fa3c0ff0bce237081fd4cdbc80de1dc68e95430672 + languageName: node + linkType: hard + +"side-channel-weakmap@npm:^1.0.2": + version: 1.0.2 + resolution: "side-channel-weakmap@npm:1.0.2" + dependencies: + call-bound: "npm:^1.0.2" + es-errors: "npm:^1.3.0" + get-intrinsic: "npm:^1.2.5" + object-inspect: "npm:^1.13.3" + side-channel-map: "npm:^1.0.1" + checksum: 10c0/71362709ac233e08807ccd980101c3e2d7efe849edc51455030327b059f6c4d292c237f94dc0685031dd11c07dd17a68afde235d6cf2102d949567f98ab58185 + languageName: node + linkType: hard + +"side-channel@npm:^1.1.0": + version: 1.1.0 + resolution: "side-channel@npm:1.1.0" + dependencies: + es-errors: "npm:^1.3.0" + object-inspect: "npm:^1.13.3" + side-channel-list: "npm:^1.0.0" + side-channel-map: "npm:^1.0.1" + side-channel-weakmap: "npm:^1.0.2" + checksum: 10c0/cb20dad41eb032e6c24c0982e1e5a24963a28aa6122b4f05b3f3d6bf8ae7fd5474ef382c8f54a6a3ab86e0cac4d41a23bd64ede3970e5bfb50326ba02a7996e6 + languageName: node + linkType: hard + +"signal-exit@npm:^4.0.1": + version: 4.1.0 + resolution: "signal-exit@npm:4.1.0" + checksum: 10c0/41602dce540e46d599edba9d9860193398d135f7ff72cab629db5171516cfae628d21e7bfccde1bbfdf11c48726bc2a6d1a8fb8701125852fbfda7cf19c6aa83 + languageName: node + linkType: hard + +"simple-swizzle@npm:^0.2.2": + version: 0.2.2 + resolution: "simple-swizzle@npm:0.2.2" + dependencies: + is-arrayish: "npm:^0.3.1" + checksum: 10c0/df5e4662a8c750bdba69af4e8263c5d96fe4cd0f9fe4bdfa3cbdeb45d2e869dff640beaaeb1ef0e99db4d8d2ec92f85508c269f50c972174851bc1ae5bd64308 + languageName: node + linkType: hard + +"smart-buffer@npm:^4.2.0": + version: 4.2.0 + resolution: "smart-buffer@npm:4.2.0" + checksum: 10c0/a16775323e1404dd43fabafe7460be13a471e021637bc7889468eb45ce6a6b207261f454e4e530a19500cc962c4cc5348583520843b363f4193cee5c00e1e539 + languageName: node + linkType: hard + +"socks-proxy-agent@npm:^8.0.3": + version: 8.0.5 + resolution: "socks-proxy-agent@npm:8.0.5" + dependencies: + agent-base: "npm:^7.1.2" + debug: "npm:^4.3.4" + socks: "npm:^2.8.3" + checksum: 10c0/5d2c6cecba6821389aabf18728325730504bf9bb1d9e342e7987a5d13badd7a98838cc9a55b8ed3cb866ad37cc23e1086f09c4d72d93105ce9dfe76330e9d2a6 + languageName: node + linkType: hard + +"socks@npm:^2.8.3": + version: 2.8.6 + resolution: "socks@npm:2.8.6" + dependencies: + ip-address: "npm:^9.0.5" + smart-buffer: "npm:^4.2.0" + checksum: 10c0/15b95db4caa359c80bfa880ff3e58f3191b9ffa4313570e501a60ee7575f51e4be664a296f4ee5c2c40544da179db6140be53433ce41ec745f9d51f342557514 + languageName: node + linkType: hard + +"sprintf-js@npm:^1.1.3": + version: 1.1.3 + resolution: "sprintf-js@npm:1.1.3" + checksum: 10c0/09270dc4f30d479e666aee820eacd9e464215cdff53848b443964202bf4051490538e5dd1b42e1a65cf7296916ca17640aebf63dae9812749c7542ee5f288dec + languageName: node + linkType: hard + +"ssri@npm:^12.0.0": + version: 12.0.0 + resolution: "ssri@npm:12.0.0" + dependencies: + minipass: "npm:^7.0.3" + checksum: 10c0/caddd5f544b2006e88fa6b0124d8d7b28208b83c72d7672d5ade44d794525d23b540f3396108c4eb9280dcb7c01f0bef50682f5b4b2c34291f7c5e211fd1417d + languageName: node + linkType: hard + +"statuses@npm:2.0.1": + version: 2.0.1 + resolution: "statuses@npm:2.0.1" + checksum: 10c0/34378b207a1620a24804ce8b5d230fea0c279f00b18a7209646d5d47e419d1cc23e7cbf33a25a1e51ac38973dc2ac2e1e9c647a8e481ef365f77668d72becfd0 + languageName: node + linkType: hard + +"statuses@npm:^2.0.1": + version: 2.0.2 + resolution: "statuses@npm:2.0.2" + checksum: 10c0/a9947d98ad60d01f6b26727570f3bcceb6c8fa789da64fe6889908fe2e294d57503b14bf2b5af7605c2d36647259e856635cd4c49eab41667658ec9d0080ec3f + languageName: node + linkType: hard + +"stoppable@npm:1.1.0": + version: 1.1.0 + resolution: "stoppable@npm:1.1.0" + checksum: 10c0/ba91b65e6442bf6f01ce837a727ece597a977ed92a05cb9aea6bf446c5e0dcbccc28f31b793afa8aedd8f34baaf3335398d35f903938d5493f7fbe386a1e090e + languageName: node + linkType: hard + +"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^4.1.0": + version: 4.2.3 + resolution: "string-width@npm:4.2.3" + dependencies: + emoji-regex: "npm:^8.0.0" + is-fullwidth-code-point: "npm:^3.0.0" + strip-ansi: "npm:^6.0.1" + checksum: 10c0/1e525e92e5eae0afd7454086eed9c818ee84374bb80328fc41217ae72ff5f065ef1c9d7f72da41de40c75fa8bb3dee63d92373fd492c84260a552c636392a47b + languageName: node + linkType: hard + +"string-width@npm:^5.0.1, string-width@npm:^5.1.2": + version: 5.1.2 + resolution: "string-width@npm:5.1.2" + dependencies: + eastasianwidth: "npm:^0.2.0" + emoji-regex: "npm:^9.2.2" + strip-ansi: "npm:^7.0.1" + checksum: 10c0/ab9c4264443d35b8b923cbdd513a089a60de339216d3b0ed3be3ba57d6880e1a192b70ae17225f764d7adbf5994e9bb8df253a944736c15a0240eff553c678ca + languageName: node + linkType: hard + +"strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1": + version: 6.0.1 + resolution: "strip-ansi@npm:6.0.1" + dependencies: + ansi-regex: "npm:^5.0.1" + checksum: 10c0/1ae5f212a126fe5b167707f716942490e3933085a5ff6c008ab97ab2f272c8025d3aa218b7bd6ab25729ca20cc81cddb252102f8751e13482a5199e873680952 + languageName: node + linkType: hard + +"strip-ansi@npm:^7.0.1": + version: 7.1.0 + resolution: "strip-ansi@npm:7.1.0" + dependencies: + ansi-regex: "npm:^6.0.1" + checksum: 10c0/a198c3762e8832505328cbf9e8c8381de14a4fa50a4f9b2160138158ea88c0f5549fb50cb13c651c3088f47e63a108b34622ec18c0499b6c8c3a5ddf6b305ac4 + languageName: node + linkType: hard + +"supports-color@npm:^10.0.0": + version: 10.0.0 + resolution: "supports-color@npm:10.0.0" + checksum: 10c0/0e7884dfd02a07b3c6e0b235346f58c19f0201f1e44f7807583581761b354688c8577378785b5a4e3b03110809786c4c808e0e086cd91911f7b8bc59132703a8 + languageName: node + linkType: hard + +"swr@npm:^2.2.5": + version: 2.3.4 + resolution: "swr@npm:2.3.4" + dependencies: + dequal: "npm:^2.0.3" + use-sync-external-store: "npm:^1.4.0" + peerDependencies: + react: ^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 + checksum: 10c0/c5cf536c2652fc6b64d64d3ce232f8bbe25dcaffc688f852fb81cf06e28b59280ebebde752429d9801c3af8e7a956ee7242376a6386a599cedc0000b862a712d + languageName: node + linkType: hard + +"tar@npm:^7.4.3": + version: 7.4.3 + resolution: "tar@npm:7.4.3" + dependencies: + "@isaacs/fs-minipass": "npm:^4.0.0" + chownr: "npm:^3.0.0" + minipass: "npm:^7.1.2" + minizlib: "npm:^3.0.1" + mkdirp: "npm:^3.0.1" + yallist: "npm:^5.0.0" + checksum: 10c0/d4679609bb2a9b48eeaf84632b6d844128d2412b95b6de07d53d8ee8baf4ca0857c9331dfa510390a0727b550fd543d4d1a10995ad86cdf078423fbb8d99831d + languageName: node + linkType: hard + +"throttleit@npm:2.1.0": + version: 2.1.0 + resolution: "throttleit@npm:2.1.0" + checksum: 10c0/1696ae849522cea6ba4f4f3beac1f6655d335e51b42d99215e196a718adced0069e48deaaf77f7e89f526ab31de5b5c91016027da182438e6f9280be2f3d5265 + languageName: node + linkType: hard + +"tinyglobby@npm:^0.2.12": + version: 0.2.14 + resolution: "tinyglobby@npm:0.2.14" + dependencies: + fdir: "npm:^6.4.4" + picomatch: "npm:^4.0.2" + checksum: 10c0/f789ed6c924287a9b7d3612056ed0cda67306cd2c80c249fd280cf1504742b12583a2089b61f4abbd24605f390809017240e250241f09938054c9b363e51c0a6 + languageName: node + linkType: hard + +"toidentifier@npm:1.0.1": + version: 1.0.1 + resolution: "toidentifier@npm:1.0.1" + checksum: 10c0/93937279934bd66cc3270016dd8d0afec14fb7c94a05c72dc57321f8bd1fa97e5bea6d1f7c89e728d077ca31ea125b78320a616a6c6cd0e6b9cb94cb864381c1 + languageName: node + linkType: hard + +"tslib@npm:^2.4.0": + version: 2.8.1 + resolution: "tslib@npm:2.8.1" + checksum: 10c0/9c4759110a19c53f992d9aae23aac5ced636e99887b51b9e61def52611732872ff7668757d4e4c61f19691e36f4da981cd9485e869b4a7408d689f6bf1f14e62 + languageName: node + linkType: hard + +"type-is@npm:^2.0.0, type-is@npm:^2.0.1": + version: 2.0.1 + resolution: "type-is@npm:2.0.1" + dependencies: + content-type: "npm:^1.0.5" + media-typer: "npm:^1.1.0" + mime-types: "npm:^3.0.0" + checksum: 10c0/7f7ec0a060b16880bdad36824ab37c26019454b67d73e8a465ed5a3587440fbe158bc765f0da68344498235c877e7dbbb1600beccc94628ed05599d667951b99 + languageName: node + linkType: hard + +"typescript@npm:^5.8.3": + version: 5.8.3 + resolution: "typescript@npm:5.8.3" + bin: + tsc: bin/tsc + tsserver: bin/tsserver + checksum: 10c0/5f8bb01196e542e64d44db3d16ee0e4063ce4f3e3966df6005f2588e86d91c03e1fb131c2581baf0fb65ee79669eea6e161cd448178986587e9f6844446dbb48 + languageName: node + linkType: hard + +"typescript@patch:typescript@npm%3A^5.8.3#optional!builtin": + version: 5.8.3 + resolution: "typescript@patch:typescript@npm%3A5.8.3#optional!builtin::version=5.8.3&hash=5786d5" + bin: + tsc: bin/tsc + tsserver: bin/tsserver + checksum: 10c0/39117e346ff8ebd87ae1510b3a77d5d92dae5a89bde588c747d25da5c146603a99c8ee588c7ef80faaf123d89ed46f6dbd918d534d641083177d5fac38b8a1cb + languageName: node + linkType: hard + +"ufo@npm:^1.6.1": + version: 1.6.1 + resolution: "ufo@npm:1.6.1" + checksum: 10c0/5a9f041e5945fba7c189d5410508cbcbefef80b253ed29aa2e1f8a2b86f4bd51af44ee18d4485e6d3468c92be9bf4a42e3a2b72dcaf27ce39ce947ec994f1e6b + languageName: node + linkType: hard + +"undici-types@npm:~7.8.0": + version: 7.8.0 + resolution: "undici-types@npm:7.8.0" + checksum: 10c0/9d9d246d1dc32f318d46116efe3cfca5a72d4f16828febc1918d94e58f6ffcf39c158aa28bf5b4fc52f410446bc7858f35151367bd7a49f21746cab6497b709b + languageName: node + linkType: hard + +"undici@npm:^7.10.0": + version: 7.12.0 + resolution: "undici@npm:7.12.0" + checksum: 10c0/27aada7bd8d2588f146a2ba554f2f6b7593f9c2d14bf3797bbc7b74825d9bee38eb3ab61e2d0ee01bb827a9ac8017eb2991cb4f06d9ed9971c8a142d8306fbab + languageName: node + linkType: hard + +"unenv@npm:2.0.0-rc.17": + version: 2.0.0-rc.17 + resolution: "unenv@npm:2.0.0-rc.17" + dependencies: + defu: "npm:^6.1.4" + exsolve: "npm:^1.0.4" + ohash: "npm:^2.0.11" + pathe: "npm:^2.0.3" + ufo: "npm:^1.6.1" + checksum: 10c0/029ae051cf2f79d3946976b32010a6aaaa87c8783a01dc088046247e34cb40962e19d96b465df5728e6ed262da89df342c1db1d05c2c28851825a74b93b90039 + languageName: node + linkType: hard + +"unique-filename@npm:^4.0.0": + version: 4.0.0 + resolution: "unique-filename@npm:4.0.0" + dependencies: + unique-slug: "npm:^5.0.0" + checksum: 10c0/38ae681cceb1408ea0587b6b01e29b00eee3c84baee1e41fd5c16b9ed443b80fba90c40e0ba69627e30855570a34ba8b06702d4a35035d4b5e198bf5a64c9ddc + languageName: node + linkType: hard + +"unique-slug@npm:^5.0.0": + version: 5.0.0 + resolution: "unique-slug@npm:5.0.0" + dependencies: + imurmurhash: "npm:^0.1.4" + checksum: 10c0/d324c5a44887bd7e105ce800fcf7533d43f29c48757ac410afd42975de82cc38ea2035c0483f4de82d186691bf3208ef35c644f73aa2b1b20b8e651be5afd293 + languageName: node + linkType: hard + +"unpipe@npm:1.0.0": + version: 1.0.0 + resolution: "unpipe@npm:1.0.0" + checksum: 10c0/193400255bd48968e5c5383730344fbb4fa114cdedfab26e329e50dd2d81b134244bb8a72c6ac1b10ab0281a58b363d06405632c9d49ca9dfd5e90cbd7d0f32c + languageName: node + linkType: hard + +"uri-js@npm:^4.2.2": + version: 4.4.1 + resolution: "uri-js@npm:4.4.1" + dependencies: + punycode: "npm:^2.1.0" + checksum: 10c0/4ef57b45aa820d7ac6496e9208559986c665e49447cb072744c13b66925a362d96dd5a46c4530a6b8e203e5db5fe849369444440cb22ecfc26c679359e5dfa3c + languageName: node + linkType: hard + +"use-sync-external-store@npm:^1.4.0": + version: 1.5.0 + resolution: "use-sync-external-store@npm:1.5.0" + peerDependencies: + react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 + checksum: 10c0/1b8663515c0be34fa653feb724fdcce3984037c78dd4a18f68b2c8be55cc1a1084c578d5b75f158d41b5ddffc2bf5600766d1af3c19c8e329bb20af2ec6f52f4 + languageName: node + linkType: hard + +"vary@npm:^1, vary@npm:^1.1.2": + version: 1.1.2 + resolution: "vary@npm:1.1.2" + checksum: 10c0/f15d588d79f3675135ba783c91a4083dcd290a2a5be9fcb6514220a1634e23df116847b1cc51f66bfb0644cf9353b2abb7815ae499bab06e46dd33c1a6bf1f4f + languageName: node + linkType: hard + +"which@npm:^2.0.1": + version: 2.0.2 + resolution: "which@npm:2.0.2" + dependencies: + isexe: "npm:^2.0.0" + bin: + node-which: ./bin/node-which + checksum: 10c0/66522872a768b60c2a65a57e8ad184e5372f5b6a9ca6d5f033d4b0dc98aff63995655a7503b9c0a2598936f532120e81dd8cc155e2e92ed662a2b9377cc4374f + languageName: node + linkType: hard + +"which@npm:^5.0.0": + version: 5.0.0 + resolution: "which@npm:5.0.0" + dependencies: + isexe: "npm:^3.1.1" + bin: + node-which: bin/which.js + checksum: 10c0/e556e4cd8b7dbf5df52408c9a9dd5ac6518c8c5267c8953f5b0564073c66ed5bf9503b14d876d0e9c7844d4db9725fb0dcf45d6e911e17e26ab363dc3965ae7b + languageName: node + linkType: hard + +"workerd@npm:1.20250712.0": + version: 1.20250712.0 + resolution: "workerd@npm:1.20250712.0" + dependencies: + "@cloudflare/workerd-darwin-64": "npm:1.20250712.0" + "@cloudflare/workerd-darwin-arm64": "npm:1.20250712.0" + "@cloudflare/workerd-linux-64": "npm:1.20250712.0" + "@cloudflare/workerd-linux-arm64": "npm:1.20250712.0" + "@cloudflare/workerd-windows-64": "npm:1.20250712.0" + dependenciesMeta: + "@cloudflare/workerd-darwin-64": + optional: true + "@cloudflare/workerd-darwin-arm64": + optional: true + "@cloudflare/workerd-linux-64": + optional: true + "@cloudflare/workerd-linux-arm64": + optional: true + "@cloudflare/workerd-windows-64": + optional: true + bin: + workerd: bin/workerd + checksum: 10c0/fea7f9aa509b6f2ab2ccaa50a157fdc3c9d7f66a8a479db12d214725a935e2e73d93f75a69540731fd2c0cfe3087215e208ace1734a45953dc777f81aa681456 + languageName: node + linkType: hard + +"wrangler@npm:^4.22.0": + version: 4.26.0 + resolution: "wrangler@npm:4.26.0" + dependencies: + "@cloudflare/kv-asset-handler": "npm:0.4.0" + "@cloudflare/unenv-preset": "npm:2.4.1" + blake3-wasm: "npm:2.1.5" + esbuild: "npm:0.25.4" + fsevents: "npm:~2.3.2" + miniflare: "npm:4.20250712.2" + path-to-regexp: "npm:6.3.0" + unenv: "npm:2.0.0-rc.17" + workerd: "npm:1.20250712.0" + peerDependencies: + "@cloudflare/workers-types": ^4.20250712.0 + dependenciesMeta: + fsevents: + optional: true + peerDependenciesMeta: + "@cloudflare/workers-types": + optional: true + bin: + wrangler: bin/wrangler.js + wrangler2: bin/wrangler.js + checksum: 10c0/82c08638e4a8acc25eb6c3fb76bdd2144f34e44f9e31290b2490bb024b9f3f42136cc361bf7838a0392a58e02afda1ef1dc7dff735631bd66e88bdd89210bc10 + languageName: node + linkType: hard + +"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0": + version: 7.0.0 + resolution: "wrap-ansi@npm:7.0.0" + dependencies: + ansi-styles: "npm:^4.0.0" + string-width: "npm:^4.1.0" + strip-ansi: "npm:^6.0.0" + checksum: 10c0/d15fc12c11e4cbc4044a552129ebc75ee3f57aa9c1958373a4db0292d72282f54373b536103987a4a7594db1ef6a4f10acf92978f79b98c49306a4b58c77d4da + languageName: node + linkType: hard + +"wrap-ansi@npm:^8.1.0": + version: 8.1.0 + resolution: "wrap-ansi@npm:8.1.0" + dependencies: + ansi-styles: "npm:^6.1.0" + string-width: "npm:^5.0.1" + strip-ansi: "npm:^7.0.1" + checksum: 10c0/138ff58a41d2f877eae87e3282c0630fc2789012fc1af4d6bd626eeb9a2f9a65ca92005e6e69a75c7b85a68479fe7443c7dbe1eb8fbaa681a4491364b7c55c60 + languageName: node + linkType: hard + +"wrappy@npm:1": + version: 1.0.2 + resolution: "wrappy@npm:1.0.2" + checksum: 10c0/56fece1a4018c6a6c8e28fbc88c87e0fbf4ea8fd64fc6c63b18f4acc4bd13e0ad2515189786dd2c30d3eec9663d70f4ecf699330002f8ccb547e4a18231fc9f0 + languageName: node + linkType: hard + +"ws@npm:8.18.0": + version: 8.18.0 + resolution: "ws@npm:8.18.0" + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ">=5.0.2" + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + checksum: 10c0/25eb33aff17edcb90721ed6b0eb250976328533ad3cd1a28a274bd263682e7296a6591ff1436d6cbc50fa67463158b062f9d1122013b361cec99a05f84680e06 + languageName: node + linkType: hard + +"yallist@npm:^4.0.0": + version: 4.0.0 + resolution: "yallist@npm:4.0.0" + checksum: 10c0/2286b5e8dbfe22204ab66e2ef5cc9bbb1e55dfc873bbe0d568aa943eb255d131890dfd5bf243637273d31119b870f49c18fcde2c6ffbb7a7a092b870dc90625a + languageName: node + linkType: hard + +"yallist@npm:^5.0.0": + version: 5.0.0 + resolution: "yallist@npm:5.0.0" + checksum: 10c0/a499c81ce6d4a1d260d4ea0f6d49ab4da09681e32c3f0472dee16667ed69d01dae63a3b81745a24bd78476ec4fcf856114cb4896ace738e01da34b2c42235416 + languageName: node + linkType: hard + +"youch-core@npm:^0.3.3": + version: 0.3.3 + resolution: "youch-core@npm:0.3.3" + dependencies: + "@poppinss/exception": "npm:^1.2.2" + error-stack-parser-es: "npm:^1.0.5" + checksum: 10c0/fe101a037a6cfaaa4e80e3d062ff33d4b087b65e3407e65220b453c9b2a66c87ea348a7da0239b61623d929d8fa0a9e139486eaa690ef5605bb49947a2fa82f6 + languageName: node + linkType: hard + +"youch@npm:4.1.0-beta.10": + version: 4.1.0-beta.10 + resolution: "youch@npm:4.1.0-beta.10" + dependencies: + "@poppinss/colors": "npm:^4.1.5" + "@poppinss/dumper": "npm:^0.6.4" + "@speed-highlight/core": "npm:^1.2.7" + cookie: "npm:^1.0.2" + youch-core: "npm:^0.3.3" + checksum: 10c0/588d65aa5837a46c8473cf57a9129115383f57aad5899915d37005950decfefc66bec85b8a1262dbefd623a122c279095074655889317311a554f9c2e290a5b3 + languageName: node + linkType: hard + +"zod-to-json-schema@npm:^3.24.1": + version: 3.24.6 + resolution: "zod-to-json-schema@npm:3.24.6" + peerDependencies: + zod: ^3.24.1 + checksum: 10c0/b907ab6d057100bd25a37e5545bf5f0efa5902cd84d3c3ec05c2e51541431a47bd9bf1e5e151a244273409b45f5986d55b26e5d207f98abc5200702f733eb368 + languageName: node + linkType: hard + +"zod@npm:3.22.3": + version: 3.22.3 + resolution: "zod@npm:3.22.3" + checksum: 10c0/cb4b24aed7dec98552eb9042e88cbd645455bf2830e5704174d2da96f554dabad4630e3b4f6623e1b6562b9eaa43535a37b7f2011f29b8d8e9eabe1ddf3b656b + languageName: node + linkType: hard + +"zod@npm:^3.23.8, zod@npm:^3.24.2, zod@npm:^3.25.67": + version: 3.25.76 + resolution: "zod@npm:3.25.76" + checksum: 10c0/5718ec35e3c40b600316c5b4c5e4976f7fee68151bc8f8d90ec18a469be9571f072e1bbaace10f1e85cf8892ea12d90821b200e980ab46916a6166a4260a983c + languageName: node + linkType: hard diff --git a/package.json b/package.json index f7a298020..ba4568bd8 100644 --- a/package.json +++ b/package.json @@ -128,8 +128,12 @@ } }, "scripts": { - "build": "shx rm -rf dist && tsc -b && oclif manifest", + "build": "shx rm -rf dist && tsc -b && oclif manifest && oclif readme --multi", + "build:mcp-shared": "tsc --project tsconfig.mcp.json", "build:tar": "oclif pack tarballs", + "build:worker": "cd mcp-worker && yarn build", + "deploy:worker": "cd mcp-worker && yarn deploy", + "dev:worker": "cd mcp-worker && yarn dev", "format": "prettier --write \"src/**/*.{ts,js,json}\" \"test/**/*.{ts,js,json}\" \"test-utils/**/*.{ts,js,json}\" \"*.{ts,js,json,md}\"", "format:check": "prettier --check \"src/**/*.{ts,js,json}\" \"test/**/*.{ts,js,json}\" \"test-utils/**/*.{ts,js,json}\" \"*.{ts,js,json,md}\"", "lint": "eslint . --config eslint.config.mjs", diff --git a/src/index.ts b/src/index.ts index 0237950aa..a4371daa7 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1 +1,22 @@ -export { run } from '@oclif/core' +/** + * DevCycle MCP Cloudflare Worker Entry Point + * + * For now, this is a placeholder that demonstrates the package structure. + * In Phase 3, this will import the worker implementation from the main CLI package + * to maintain a clean separation between packages while sharing code. + */ + +export default { + fetch(request: Request, env: any, ctx: any): Response { + return new Response( + JSON.stringify({ + message: 'DevCycle MCP Server - Coming Soon', + timestamp: new Date().toISOString(), + path: new URL(request.url).pathname, + }), + { + headers: { 'Content-Type': 'application/json' }, + }, + ) + }, +} diff --git a/src/mcp/worker/apiClient.ts b/src/mcp/worker/apiClient.ts new file mode 100644 index 000000000..6af6d3c28 --- /dev/null +++ b/src/mcp/worker/apiClient.ts @@ -0,0 +1,171 @@ +import type { UserProps, Env, DevCycleJWTClaims } from './types' +import { IDevCycleApiClient } from '../api/interface' + +/** + * Worker-specific API client implementation that uses OAuth tokens from JWT claims + * instead of API keys from local configuration files. + */ +export class WorkerApiClient implements IDevCycleApiClient { + constructor( + private props: UserProps, + private env: Env, + ) {} + + /** + * Execute an API operation with OAuth token authentication and consistent logging + */ + async executeWithLogging( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + requiresProject: boolean = true, + ): Promise { + const authToken = this.getAuthToken() + const projectKey = requiresProject ? this.getProjectKey() : '' + + console.log(`Worker MCP ${operationName}:`, { + args, + userId: this.getUserId(), + orgId: this.getOrgId(), + projectKey: requiresProject ? projectKey : 'N/A', + }) + + try { + const result = await operation(authToken, projectKey) + console.log(`Worker MCP ${operationName} completed successfully`) + return result + } catch (error) { + console.error(`Worker MCP ${operationName} error:`, { + error: error instanceof Error ? error.message : String(error), + args, + userId: this.getUserId(), + orgId: this.getOrgId(), + }) + throw error + } + } + + /** + * Execute an API operation and include dashboard links in the response + */ + async executeWithDashboardLink( + operationName: string, + args: any, + operation: (authToken: string, projectKey: string) => Promise, + dashboardLink: (orgId: string, projectKey: string, result: T) => string, + ): Promise<{ result: T; dashboardLink: string }> { + const authToken = this.getAuthToken() + const projectKey = this.getProjectKey() + const orgId = this.getOrgId() + + console.log(`Worker MCP ${operationName} (with dashboard link):`, { + args, + userId: this.getUserId(), + orgId, + projectKey, + }) + + try { + const result = await operation(authToken, projectKey) + const link = dashboardLink(orgId, projectKey, result) + + console.log( + `Worker MCP ${operationName} completed successfully with dashboard link`, + ) + + return { + result, + dashboardLink: link, + } + } catch (error) { + console.error(`Worker MCP ${operationName} error:`, { + error: error instanceof Error ? error.message : String(error), + args, + userId: this.getUserId(), + orgId, + }) + throw error + } + } + + /** + * Get the OAuth access token for API authentication + */ + private getAuthToken(): string { + if (!this.props.tokenSet?.accessToken) { + throw new Error('No access token available in user props') + } + return this.props.tokenSet.accessToken + } + + /** + * Get the project key from JWT claims or environment variables + */ + private getProjectKey(): string { + const claims = this.props.claims as DevCycleJWTClaims + + // Try from JWT claims first - this allows user-specific project context + if (claims?.project_key) { + return claims.project_key + } + + // Fall back to environment variable for single-project deployments + if (this.env.DEFAULT_PROJECT_KEY) { + return this.env.DEFAULT_PROJECT_KEY + } + + throw new Error( + 'No project key found in JWT claims or environment variables. ' + + 'Either set DEFAULT_PROJECT_KEY in worker environment or include project_key in JWT claims.', + ) + } + + /** + * Get the organization ID from JWT claims + */ + private getOrgId(): string { + const claims = this.props.claims as DevCycleJWTClaims + + if (claims?.org_id) { + return claims.org_id + } + + throw new Error('No organization ID found in JWT claims') + } + + /** + * Get the user ID from JWT claims (for logging purposes) + */ + private getUserId(): string { + const claims = this.props.claims as DevCycleJWTClaims + return claims?.sub || claims?.email || 'unknown' + } + + /** + * Check if the user has access to the required project + */ + public hasProjectAccess(projectKey?: string): boolean { + try { + const userProjectKey = this.getProjectKey() + return !projectKey || userProjectKey === projectKey + } catch { + return false + } + } + + /** + * Get user context information for debugging + */ + public getUserContext() { + const claims = this.props.claims as DevCycleJWTClaims + return { + userId: this.getUserId(), + orgId: this.getOrgId(), + projectKey: this.getProjectKey(), + email: claims?.email, + name: claims?.name, + hasAccessToken: !!this.props.tokenSet?.accessToken, + hasRefreshToken: !!this.props.tokenSet?.refreshToken, + } + } +} diff --git a/src/mcp/worker/auth.ts b/src/mcp/worker/auth.ts new file mode 100644 index 000000000..0439068c9 --- /dev/null +++ b/src/mcp/worker/auth.ts @@ -0,0 +1,233 @@ +import type { + TokenExchangeCallbackOptions, + TokenExchangeCallbackResult, + AuthorizeParams, + CallbackParams, + ConsentParams, +} from '@cloudflare/workers-oauth-provider' +import * as oauth from 'oauth4webapi' +import { Hono } from 'hono' +import type { UserProps, Env, DevCycleJWTClaims } from './types' + +/** + * Get OIDC configuration for Auth0 + */ +async function getOidcConfig(options: { + client_id: string + client_secret: string + issuer: string +}) { + const as = await oauth + .discoveryRequest(new URL(options.issuer)) + .then((response) => + oauth.processDiscoveryResponse(new URL(options.issuer), response), + ) + + const client: oauth.Client = { + client_id: options.client_id, + token_endpoint_auth_method: 'client_secret_basic', + } + + const clientAuth = oauth.ClientSecretBasic(options.client_secret) + + return { as, client, clientAuth } +} + +/** + * Parse JWT token to extract claims + */ +function parseJWT(token: string): DevCycleJWTClaims { + try { + const parts = token.split('.') + if (parts.length !== 3) { + throw new Error('Invalid JWT format') + } + + const payload = parts[1] + const decoded = JSON.parse( + atob(payload.replace(/-/g, '+').replace(/_/g, '/')), + ) + return decoded as DevCycleJWTClaims + } catch (error) { + throw new Error(`Failed to parse JWT: ${error}`) + } +} + +/** + * Token Exchange Callback + * + * Handles the token exchange process for OAuth authentication with DevCycle/Auth0. + * This function processes both authorization code and refresh token flows. + */ +export async function tokenExchangeCallback( + options: TokenExchangeCallbackOptions, +): Promise | void> { + const { grantType, env } = options + + // During the Authorization Code Exchange, preserve token TTL from Auth0 + if (grantType === 'authorization_code') { + const idToken = options.props.tokenSet.idToken + if (!idToken) { + throw new Error('No ID token received from Auth0') + } + + // Extract claims from the ID token + const claims = parseJWT(idToken) + + // Validate that we have the necessary DevCycle context + if (!claims.org_id) { + throw new Error( + 'DevCycle organization ID not found in token claims', + ) + } + + return { + accessTokenTTL: options.props.tokenSet.accessTokenTTL, + newProps: { + claims, + tokenSet: { + accessToken: options.props.tokenSet.accessToken, + idToken: options.props.tokenSet.idToken, + refreshToken: options.props.tokenSet.refreshToken || '', + }, + } as UserProps, + } + } + + // Handle refresh token flow + if (grantType === 'refresh_token') { + const auth0RefreshToken = options.props.tokenSet.refreshToken + if (!auth0RefreshToken) { + throw new Error('No Auth0 refresh token found') + } + + const { as, client, clientAuth } = await getOidcConfig({ + client_id: env.AUTH0_CLIENT_ID, + client_secret: env.AUTH0_CLIENT_SECRET, + issuer: `https://${env.AUTH0_DOMAIN}/`, + }) + + // Perform the refresh token exchange with Auth0 + const response = await oauth.refreshTokenGrantRequest( + as, + client, + clientAuth, + auth0RefreshToken, + ) + const refreshTokenResponse = await oauth.processRefreshTokenResponse( + as, + client, + response, + ) + + // Extract claims from the new ID token + let claims: DevCycleJWTClaims + if (refreshTokenResponse.id_token) { + claims = parseJWT(refreshTokenResponse.id_token) + } else { + // Fall back to existing claims if no new ID token + claims = options.props.claims as DevCycleJWTClaims + } + + // Return updated token set and claims + return { + accessTokenTTL: refreshTokenResponse.expires_in, + newProps: { + claims, + tokenSet: { + accessToken: refreshTokenResponse.access_token, + idToken: + refreshTokenResponse.id_token || + options.props.tokenSet.idToken, + refreshToken: + refreshTokenResponse.refresh_token || auth0RefreshToken, + }, + } as UserProps, + } + } + + // For other grant types, no special handling needed + return undefined +} + +/** + * Authorization endpoint handler + * Initiates the OAuth flow with DevCycle/Auth0 + */ +export async function authorize(c: any): Promise { + const params = c.req.query() as AuthorizeParams + + // Add DevCycle-specific scopes if not already present + const defaultScopes = ['openid', 'profile', 'email', 'offline_access'] + const requestedScopes = params.scope?.split(' ') || [] + const allScopes = [...new Set([...defaultScopes, ...requestedScopes])] + + // Forward to the OAuth provider with enhanced scopes + return c.env.OAUTH_PROVIDER.authorize({ + ...params, + scope: allScopes.join(' '), + }) +} + +/** + * OAuth callback handler + * Processes the callback from Auth0 after user authentication + */ +export async function callback(c: any): Promise { + const params = c.req.query() as CallbackParams + return c.env.OAUTH_PROVIDER.callback(params) +} + +/** + * Consent confirmation handler + * Handles user consent for the OAuth flow + */ +export async function confirmConsent(c: any): Promise { + const formData = await c.req.formData() + const params = Object.fromEntries(formData.entries()) as ConsentParams + return c.env.OAUTH_PROVIDER.confirmConsent(params) +} + +/** + * Health check endpoint + */ +export function healthCheck() { + return new Response( + JSON.stringify({ + status: 'ok', + service: 'DevCycle MCP Server', + timestamp: new Date().toISOString(), + }), + { + headers: { 'Content-Type': 'application/json' }, + }, + ) +} + +/** + * Create the Hono app with OAuth routes + */ +export function createAuthApp(): Hono<{ Bindings: Env }> { + const app = new Hono<{ Bindings: Env }>() + + // OAuth flow endpoints + app.get('/authorize', authorize) + app.post('/authorize/consent', confirmConsent) + app.get('/callback', callback) + + // Health check + app.get('/health', () => healthCheck()) + + // Info endpoint for debugging + app.get('/info', (c) => { + return c.json({ + service: 'DevCycle MCP Server', + version: '1.0.0', + auth0Domain: c.env.AUTH0_DOMAIN, + apiBaseUrl: c.env.API_BASE_URL || 'https://api.devcycle.com', + hasDefaultProject: !!c.env.DEFAULT_PROJECT_KEY, + }) + }) + + return app +} diff --git a/src/mcp/worker/index.ts b/src/mcp/worker/index.ts new file mode 100644 index 000000000..162997237 --- /dev/null +++ b/src/mcp/worker/index.ts @@ -0,0 +1,244 @@ +import OAuthProvider, { + type OAuthHelpers, +} from '@cloudflare/workers-oauth-provider' +import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js' +import { McpAgent } from 'agents/mcp' +import { Hono } from 'hono' +import { createAuthApp, tokenExchangeCallback } from './auth' +import { WorkerApiClient } from './apiClient' +import { MCPToolRegistry, registerAllTools } from '../tools' +import type { UserProps, Env } from './types' + +/** + * DevCycle MCP Server for Cloudflare Workers + * + * This class extends McpAgent to provide DevCycle feature flag management + * through the Model Context Protocol over Server-Sent Events (SSE). + * It integrates OAuth authentication, tool registry, and Worker-specific API client. + */ +export class DevCycleMCP extends McpAgent< + Env, + Record, + UserProps +> { + // The MCP server instance that handles protocol communication + // @ts-ignore - Type compatibility issue with MCP SDK versions + server = new McpServer({ + name: 'DevCycle CLI MCP Server', + version: '1.0.0', + }) + + // Tool registry containing all DevCycle MCP tools + private registry = new MCPToolRegistry() + + // Worker-specific API client that uses OAuth tokens + private apiClient: WorkerApiClient + + /** + * Initialize the MCP server with tools and handlers + */ + async init() { + console.log('Initializing DevCycle MCP Worker', { + userId: this.getUserId(), + orgId: this.getOrgId(), + hasProject: this.hasProjectKey(), + }) + + // Initialize the Worker-specific API client with OAuth tokens + this.apiClient = new WorkerApiClient(this.props, this.env) + + // Register all tools from the shared registry + registerAllTools(this.registry) + + console.log( + `Registered ${this.registry.size()} MCP tools:`, + this.registry.getToolNames(), + ) + + // Add a debug tool to inspect user context + this.server.tool( + 'whoami', + 'Get the current DevCycle user details and context', + {}, + async () => { + try { + const userContext = this.apiClient.getUserContext() + return { + content: [ + { + type: 'text', + text: JSON.stringify( + { + message: + 'DevCycle MCP Server - User Context', + context: userContext, + serverInfo: { + name: 'DevCycle CLI MCP Server', + version: '1.0.0', + environment: + this.env.NODE_ENV || + 'production', + apiBaseUrl: + this.env.API_BASE_URL || + 'https://api.devcycle.com', + }, + }, + null, + 2, + ), + }, + ], + } + } catch (error) { + return { + content: [ + { + type: 'text', + text: `Error retrieving user context: ${error instanceof Error ? error.message : String(error)}`, + }, + ], + } + } + }, + ) + + // Dynamically create MCP protocol handlers for each registered tool + for (const tool of this.registry.getAll()) { + this.server.tool( + tool.name, + tool.description, + tool.inputSchema, + async (args) => { + try { + console.log(`Executing tool: ${tool.name}`, { + args, + userId: this.getUserId(), + }) + + // Execute tool with Worker-specific API client that uses OAuth tokens + const result = await this.registry.execute( + tool.name, + args, + this.apiClient, + ) + + // Format response according to MCP protocol expectations + // Check if result has dashboardLink (from executeWithDashboardLink) + let responseText: string + if ( + result && + typeof result === 'object' && + 'result' in result && + 'dashboardLink' in result + ) { + responseText = JSON.stringify( + { + data: result.result, + dashboardLink: result.dashboardLink, + }, + null, + 2, + ) + } else { + responseText = JSON.stringify(result, null, 2) + } + + return { + content: [ + { + type: 'text', + text: responseText, + }, + ], + } + } catch (error) { + console.error(`Tool execution error: ${tool.name}`, { + error: + error instanceof Error + ? error.message + : String(error), + args, + userId: this.getUserId(), + }) + + // Standardized error handling across all tools + const errorMessage = + error instanceof Error + ? error.message + : String(error) + return { + content: [ + { + type: 'text', + text: `Error executing ${tool.name}: ${errorMessage}`, + }, + ], + } + } + }, + ) + } + + console.log('DevCycle MCP Worker initialization completed') + } + + /** + * Get user ID from claims for logging + */ + private getUserId(): string { + return this.props.claims?.sub || this.props.claims?.email || 'unknown' + } + + /** + * Get organization ID from claims + */ + private getOrgId(): string { + return (this.props.claims as any)?.org_id || 'unknown' + } + + /** + * Check if user has project key available + */ + private hasProjectKey(): boolean { + try { + this.apiClient.getUserContext() + return true + } catch { + return false + } + } +} + +/** + * Create and configure the main Cloudflare Worker export + * + * This sets up the OAuth Provider with the MCP server mounted on the /sse endpoint + * and includes all the necessary authentication and routing handlers. + */ +function createWorker() { + // Initialize the Hono app with OAuth routes + const authApp = createAuthApp() + + // Create the OAuth Provider with MCP server integration + return new OAuthProvider({ + // Mount the MCP server on the /sse endpoint for Server-Sent Events communication + // @ts-expect-error - Type compatibility with OAuth provider and MCP agent + apiHandler: DevCycleMCP.mount('/sse'), + apiRoute: '/sse', + + // OAuth endpoint configuration + authorizeEndpoint: '/authorize', + clientRegistrationEndpoint: '/signup', + tokenEndpoint: '/token', + + // Auth app handles all OAuth-related routes + // @ts-expect-error - Type compatibility with OAuth provider + defaultHandler: authApp, + + // Token exchange callback for handling OAuth token flows + tokenExchangeCallback, + }) +} + +// Export the configured Worker +export default createWorker() diff --git a/src/mcp/worker/types.ts b/src/mcp/worker/types.ts new file mode 100644 index 000000000..812733c1c --- /dev/null +++ b/src/mcp/worker/types.ts @@ -0,0 +1,65 @@ +import type { JWTPayload } from 'jose' + +/** + * User properties for Cloudflare Worker MCP implementation + * Contains OAuth token information and JWT claims from DevCycle/Auth0 + */ +export type UserProps = { + /** JWT claims containing user identity and DevCycle context */ + claims: JWTPayload + /** OAuth token set for API authentication */ + tokenSet: { + accessToken: string + idToken: string + refreshToken: string + } +} + +/** + * Cloudflare Worker environment bindings + */ +export interface Env { + // OAuth Provider KV namespace for storing session data + OAUTH_KV: KVNamespace + + // DevCycle API configuration + API_BASE_URL?: string + DEFAULT_PROJECT_KEY?: string + + // Auth0 configuration + AUTH0_DOMAIN: string + AUTH0_CLIENT_ID: string + AUTH0_CLIENT_SECRET: string + AUTH0_AUDIENCE?: string + AUTH0_SCOPE?: string + + // Worker configuration + NODE_ENV?: string + + // AI binding (if needed for future features) + AI?: any +} + +/** + * Extended JWT claims that may contain DevCycle-specific information + */ +export interface DevCycleJWTClaims extends JWTPayload { + /** DevCycle organization ID */ + org_id?: string + /** DevCycle project key (if user has a default project) */ + project_key?: string + /** User's email */ + email?: string + /** User's name */ + name?: string + /** Auth0 subject identifier */ + sub?: string + /** Audience */ + aud?: string | string[] + /** Issuer */ + iss?: string + /** Expiration time */ + exp?: number + /** Issued at time */ + iat?: number +} diff --git a/tsconfig.json b/tsconfig.json index f9bc06b72..ff852e68c 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -24,5 +24,5 @@ "tsBuildInfoFile": "./dist/.tsbuildinfo" }, "include": ["src/**/*"], - "exclude": ["src/**/*.test.ts", "dist", "node_modules", "bin"] + "exclude": ["src/**/*.test.ts", "src/mcp/worker/**/*", "dist", "node_modules", "bin"] } diff --git a/tsconfig.mcp.json b/tsconfig.mcp.json new file mode 100644 index 000000000..c30f7f492 --- /dev/null +++ b/tsconfig.mcp.json @@ -0,0 +1,20 @@ +{ + "extends": "./tsconfig.json", + "compilerOptions": { + "outDir": "./dist/mcp-shared", + "declaration": true, + "declarationMap": true, + "sourceMap": true + }, + "include": [ + "src/mcp/tools/**/*", + "src/mcp/api/interface.ts", + "src/mcp/worker/**/*", + "src/api/**/*" + ], + "exclude": [ + "src/mcp/worker/**/*", + "**/*.test.ts", + "test/**/*" + ] +} \ No newline at end of file From ff23fe584bd941a0cdb30fd91a0d5f9ff87135db Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Mon, 28 Jul 2025 11:37:42 -0400 Subject: [PATCH 07/31] feat: move MCP Worker logic to /mcp-worker --- {src => docs}/mcp/cloudflare-worker-plan.md | 9 +- mcp-worker/.yarn/install-state.gz | Bin 235015 -> 235343 bytes mcp-worker/README.md | 2 - mcp-worker/package.json | 5 +- .../worker => mcp-worker/src}/apiClient.ts | 11 +- {src/mcp/worker => mcp-worker/src}/auth.ts | 41 ++- mcp-worker/src/index.ts | 248 +++++++++++++++++- {src/mcp/worker => mcp-worker/src}/types.ts | 1 - mcp-worker/tsconfig.json | 3 +- mcp-worker/wrangler.toml | 8 +- mcp-worker/yarn.lock | 29 +- src/mcp/worker/index.ts | 244 ----------------- tsconfig.json | 2 +- tsconfig.mcp.json | 2 +- 14 files changed, 286 insertions(+), 319 deletions(-) rename {src => docs}/mcp/cloudflare-worker-plan.md (98%) rename {src/mcp/worker => mcp-worker/src}/apiClient.ts (92%) rename {src/mcp/worker => mcp-worker/src}/auth.ts (85%) rename {src/mcp/worker => mcp-worker/src}/types.ts (97%) delete mode 100644 src/mcp/worker/index.ts diff --git a/src/mcp/cloudflare-worker-plan.md b/docs/mcp/cloudflare-worker-plan.md similarity index 98% rename from src/mcp/cloudflare-worker-plan.md rename to docs/mcp/cloudflare-worker-plan.md index 4a6b3c922..6476fc87e 100644 --- a/src/mcp/cloudflare-worker-plan.md +++ b/docs/mcp/cloudflare-worker-plan.md @@ -285,12 +285,9 @@ export class WorkerApiClient implements IDevCycleApiClient { // Try from JWT claims first - this allows user-specific project context if (this.props.claims?.project_key) { return this.props.claims.project_key as string; - } - // Fall back to environment variable for single-project deployments - if (this.env.DEFAULT_PROJECT_KEY) { - return this.env.DEFAULT_PROJECT_KEY; - } - throw new Error("No project key found in claims or environment"); + } + + throw new Error("No project key found in claims"); } private getOrgId(): string { diff --git a/mcp-worker/.yarn/install-state.gz b/mcp-worker/.yarn/install-state.gz index 1ec1600ca702c0555c70eb389df743c7a03b85d8..095e39f5ace364435f9aaa7d5242d7fd891039b0 100644 GIT binary patch delta 202803 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

-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⪙+|Y5x9Bil`Jg>D_D~f?{ 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%0A^!zC<8Nu4~|I? zuwX5eh7)(!C5C5?rm!&2E%Q3ST83ni!>K2epjNx9cCtA!%54sl#RPgHVPcuYUna8TQ?EX z9vfSedH=L{XiM>v`O9k`3L8H}m;2lA-U6h|ujnieeHEWx8y?!4f6-pM3^Oe+34dn# zbxZ3LOY1Y*YXVxPuZn1zs#f41in+K=qi}XAB`?^YtuM@;YEG_(jW;UVv5*uh+(EvL z3^A!nh-t4G@#v*&@gy9xOi#6ChSYhm&b&&VUVQf(C!3FGED9SVX<3ZCxiq9jUqOh< zYgRiTg>_J(R2x*uBfIs02|SNpMt?I=!X61I16b?}0eZkTPMeGv;6kSbM8Lhbgt=MyRV#l&{5dd!QJnkd_Zn|@|oW|`RHu_ z&R0Kv^Y!}==Di=dd*8qRhkV{Ud;IBbdb*~G2e^JEh68TU72r!|H?^pJ^nWH4YYRhx zs5F6Fo>)XtDtk`N;34Uyw-kv6O!SffVZ|)8XE!XS+Vku>feZBBkY~5t*>8U9*}c2( zyyNTp9^bvc&c5rrzv1TVTL-P1)Rv{*- zNCef<+C+K}Dma4R9?^OTB!8{FY*}?RuelJ`$8)9Oa|O}DC8KqFe89W7IVOP(Na|ezU z_*S64BwpZ+Wr4m!UFzV-*1BgxC$>=}WK=;8f|bg$+rU-GDp{x2Ixqu5)Dw#%oH(@} z>XXn-CI!#Td9wkTrBzxhg{&>k2sm1?U2&Cw#I&Lynro2JpdgIXh*A+AjTe3&=ogaf Vq>wi6yz-;p@;`)Zb&MrZ3jlQX&N~1A delta 202703 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
&~9^!I$mlXK(qx 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

S>EoUGzz(!fS)xF)Sa#8d1AM8HnuIMu|V1?e{_ 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

JHdkj?SrvtdTNC06N?a)S9z>js=iS6R94wt`*RK zw;umoKXrBg(S=dlh$`TX?+jK*mg?M;|AD} zcasS|#7R`t=yOriux^&U<)y&!jin62)%j8lQ4B5FqXGSeBi#@ht>} zT|Hcm?NV#)FkLs{ZarAKjt2AQ-nOs?enyeZPC^So6(x+bF_6Zs#j?nkPlIk5T$+?hPbRalTx_5 zm(p$rwvBBIfb+Sfv5*Hp$Y8l~!}yxG9{$XqXYD7C8u)L$ct0Pd^n2jrY;NIysfbbO z16P2=@)=@!k&}?EKndA9y`jKtf#&bB*N5C$5=XG~Ms&)$7&F&4Wue`%pK@$*X%r)L@uo3r)yXwi!7?(J>@l*g%ZginJG8%041DY9 zy?cHk8Te*Cd-~ba2RO7FFWrOJ&#tz6dq-Etz6*%bII*kRI6Ae5k2uMcDvod3cRcinr7P5;S8ME^=2B}f76lO*x*nfC1lO9pv?(M zVX#Icj}Ej!H?M5MgF`V#z57otpGa=EP1O1slY93ahJ^+z0?_mkO_9l3pykea<{WaV z^pRyYa*mU2j!4;mjuu}R&E95TX-w$GWDr)Nx4vXyxa z-8<(F)xcwMFz193#M<3|_AUweUkJGz|G5llB2oJ^qOpm83b3@*sn^jXWWC8jh9>e6 z+!|7X8l-j(-vsn|5Kxi$l1T;L70;l4s;9B19As3^)ka%EDk4>Ja*uJnE#LZid*GFQ z{R)uS=l2gbstw0OY z0EfnENZY)B&sbHXW=@Nt7c^33A05f>k_A^31tQhFG3+i!36t`}EB9=7|M~mS(#YVj z7IR%PM#m7GmhAwlXS5|ZI}HE0j&dZLvUU`E5H~tjhZn-^0~hOyJg)#>ptVzS6%`qe z0+d52b@ag-IMdS_0ua=`x{v*>7w*AhKd*)_^IZ&oUp|D#{=aw+kNs*D$V1<8l&hxi zLgam0a&esT$XRnJevt}~mT3t7oSqv5nN@35n>;)d;WnFq3-rC#@t}&If0>->lP+4Ehm9vgf8u-=@%DeyaYro$gzA4lPprQII zNV*<>ewqX31=HnI&9oIhCY(LJqiaE1Ep4=>c&yIYGDlTHojRl9bgBeI166L;o}H&5 ztFsF(s~49`H<4oSAf*q3^MQAPU%ihJ@%5)kmzm zjS>>3o>P3e`k)pxCaPWY*>Y7JTe}Z{9>9ZSB8Xu=dGh0@`}Koqz^#|=(PSdNN+x<2RK;zJbvEmfVTsh_Ntc8I zHyzt$&l;^qUqmq{GR5!?_^Pg`>y0!fr}eHH!;Y<~oHbgz_#(vhApSUt30Vm#bPkGt zc84_xq4szG6;7twqMQ;;4H)HSh%5yKoca*Z>uo?rqyzF@8aBJtdNUj(&@&0UM+d}P z&z|6mdnIV`$U|e0ZIzJirqdU$=-!PxXtaxWD(l^U{XsNl{+o~9{U#7c+u+X9Yc-~- z<*-GG$&6T54&FMq&9lcEV%;xUFkvNsM_R3U7I^#$c_UC}!%xJ~rBO2oQCzhka&4Y_ z4|ogL>2+MXr9O=1`zmb$w_dtOa{1miIE;5;aCj4A62}e?4Uo(ChU>`MoPyS%WAL>F zqm4nFvz#SIn1qt$*nqRUoY9uVX)74ss@2D|Kz2z>C>oP$`=~jF3`=c=N{+UF4P?39 z{kI=|2wTyA_aSToU!5+-!+TX5BGA3Td1!%4axuuW$mq7yWI};d zPD1IqZ1e^cc*e0NU2I)f{I~9*U)NDTe&vt%xo*8~kMz0PRiEqKw)`+u~RHNWN3o7bEh>&Q1!y{*>qj^F- zMyt81kZUn%dE#bTjym0cH{SvNrw?KW_@6(79pLL5)dzp0%BAdr$gnj42}uO=w$aC7 zj@3_Q*E1C%?PrXg!`8rEpZ(GSKYbh8zGtlFK06pA>_#RPJnUjtp1XFJxqxIhA_^!_ zFW!*8uG^Tmo>N^vB6v8SysA&?Hy=#QZ@h4iM#uNJO4JY13hhyUtwWJ3JTeG!(P-Mh zIJF}=d2F?Vw4af!ZF9u&j6INyQhSzB2e6|$ZCSP{<|?0b<}#-YrXyS@rU{JCC`ekv3t~A{rRJVhg&b+BjL4gQ%Bl|NgXLY=xDTI=jd#pwW#B> z8o;@ea@!dQY4@cIx2c2J)=a}7XJz#vbSEjN8)Sgtx?yTuRpjaZo@`0Teoa~%cf@1nF9n%Na6cQ_iBhh%|*y4 zUI1g}*@w}7un@D=XN69*cM3}@rc~tzo>DWjA)-gN3Ok|?8hl`pGS`vZ*H7H7+fLU{ z+@+4VfBlnZ^??0w>y>+?kf1BAH+_heDQs%8KN$>k>y0`P?Ru zjUQJG+@y`O4(4}kXJ_N>3FT##EZ8*~Z#y!7$69zXucs3?{&B8p0r}$Di&szb#q-~& zSFaya2a@hc!jZVp8WRf(eV~8HLvyDx*?G+VUQG2r0#X ztIeat0)tKGfRR9E^sxTl&FZdf; zmuuWKtUhhT>NffUzt_;bEET}>5W14B$@Zy73Gu`T(_8b%Y`_Bdss$$SNbVx)eJL77 z18-kWnTz*EAUcBrvCn9GVk5qxmo9+ zk$W75iF_#Og#_asWEUzc+$Kl5#jm{C%;c@(^Uc@q06UDSW+J}zq_si16kPIu1%)`n z#(Ahis=J^Th+5q>&30q%q1u}ctG$uVNeyx9n>DAH6fzXmDnzu++O5-IOPhWc;v#`P z*B$%rfBDX%?;grDAom&MnH^-OSAwDEHP|=OtqAs7(pfsVoh~`xGM%&~>PTNhxUW>H zer5$?aFHEuZTTGAX2+ior`E=Q0gAL>dKh~FHC-yw@BYtU25x`F*;#znXpMUy|CswY zM_E+84jr^nM1w|eb8OmE6A4H(hzRhC1{}2jkHCWDNyhty5X}M5`N5+I1pMlV^nD4_5DuV03<{hxdv`raSE|Lo<<7q4F5Ke=qhcmMY`27u4EwxUTBC&xW4()ar8Of{1+0lvYLg{E>J2>VVHeI<9hTYl5+Sa8J z6>`#7WQl>qF~fOs=Gk3{#rjtD)1o5A1InLqM#qtZ&17U4IzxdrLwKUO)uQ`Y*`Vil zD--U~V(4tHtIvjcW9x-~eJClCCy%<$ z`Ks>kpS<$d_2k*pPalRe+{>o1#Yp4bN`qF@sNn}a zkuKiQEU`>%l;x9CwC0R-JEYPx^K?btFc4EyI*0T!+;#% zJ9cpJ<3}5(U;)|^IoE1OM+ZUy5#?*~-Cz9n@3({D=lt z0*bcx*@o|G9PI0Vge}_r^tnfG1peNIuiSQ9(G@WaYc%Nqt8|ba&Nu?|{BWd_r__{oM~?fqw71f6yK5^X=;M_wDZQefQ&UyiMk)t;bf4(zS5`UNJCRjed@l26 z#z>hzZLI3P`-QRAe9SSjF-CX|1hNwzy8-1|%HCVz6ae*qXlZWEh9O@g7vx&|IyF+R zui*WRH83rlIWChDBoee-G^BY)&5hLchMO$7vD!0Y#opTabT?dOWAW5u6zXb$G&U|c~4d(m#|Y>;O! zEKaaq<|)n`XXEzMa)oz~mAgBzoZ?d3Ew{GSaX$7Wz#Z_}P z7gX8}#>umWpGh()S@1Xj?3O~YFpx$;)d~<@UMw_!c{}d1f_Q>UK@bySrj#kfkrOBM zvThnJDMpW=6K-ZZY{uQ6`=t+If&Tn2{Q-BXKl=Gj^;<9Y-EaTW)h;zj1RB3MoWy9D ztpZD0$(yZHHnfkUW4Ap^R?wog)Wk<^YJ*3Owa4ZaoOP&n^f@+zlH!AiDNJ(t13nCH=yqdPp`=cl7SD`vHNwpR%U(6KdI-hAGDEfy=Y(Fnf}U8 zcP0+N@=UhUqLU87rV7nYG4|-wPQQ4~s-sYU(G?&I4D0H;Jdz@c+GbU=^@9j%1t$*f=@4N#9X3ZVl>4?G^+Y^{Q zn85pijGUb;2g?ur@3&ni!r^)JSVWDr-9gB03O% zxos23=)Kj+yT9>^kiVSBwn^~%0?M{~T0cl#qaod6Ov$6AZOWS6L`_n3?9DzS07NCy z7;#F?XU~#cYoFjSr^P{&eA;f*yZIPB1!WggRLyY~-~F!_yIh^=?4>b=mAKc!Z6}#0 zpoQA1^UMxsYY|||^FZZGq#08#J0^2~!h*Q+=w>ySGx4~{v8B2*I74*J%cyg;2^;L3 zEIW2--2F|g#W)j7s!hCN@6&dhQKR#b)s9`N?YYN7X;}yP%c~T0JL#MYdp2yu$Vl@47koL_ckRBaTUD zcRaba)7C^Y=+m~&D%_FV;-S7S4hj2XoonQR;k3W8Xk3@57Z5~e5 zxmpWqH4lc0OdKL3cc$zi=>XJi#I*3ZcAvYJDvdYHal8yMtRPdDDm}DMW6(Dg&%{x>`|UqyrSZo;Kfhm<=j*$_ zbX{i<#CL1b0Y+5UFi7jpm{S&a6~qnf4RXwYh@jX#hL0u+3r^qt><#UJYLk8toujjc z0h74wn9!O{2np%vWRC`a44Ri)>{Q7`*Gb`weN>SO(EV)JwRS6RU;xU=PHB_7DM~tJ zTf)??HKWi>AIF#{KAjX zNq<(a9*lx+yljtG7aznKF5f48E4J|SZ@h!C6k_&(edz8(9FWz2#2rsI=Y}Q>t;XRT zxF?Bq%oIl#jov->UK2Fw%tKVIb{vF<3UW`@0&8RKXxnYI@HyM-DVim?+dvdX?tdTN_qD#!>b zIlb8WDFs8imBRtI5=iaOf9ngIz8G-EeGuLK9~TlKA^t}ptYA0v)Ir0X^Q?u;tgxId z(#$l^sD0)cG0HiXmz)STj6a8OXhcjFho&iCtT}=}LINpG9EigO48<~QD!`HKV`6uI zA8Qd6mmZ4~=uv0HfuJLuvQNxLIs}p{ve^tw*Xcr9)8Pdass;7be}RViW~g)JNZ*Np z4L7plImL=&G3~}}>ROabYfa>CMYX*92ly$vm`@U$f?%+1nP@HS+ItAZBgKcRwP7@C zt+`q`v`Uv&dWNo^y&LDigHsgBbFdip+$h7L>Nz^NB)FU_gL7Cijm(#eFyH+{{1l=E zxz!44hhAsWU zv#g;9sd%TQ(&5TdsGwQIK#YH&?aGS{wW#2tUi6e|RMZ)8M;5{cYSM#x}1m z!)^HCqHKHRQUt%DIcOqlOvJ;4GY{HQ2^xx7ZaEo!+wux-TIdDsfvXs)GNBCxg_&zi zI?RWS2c}&+K;`trUCHkL%;l$89vcCGg_OAkyf?cxHszBbtoAvyn*=Us*`<%Z17n&0{jTd*e*RBad7)=Rt$M+CtsMKu`tOz+lnu{_M9u{`TXyncnAg z(4-Ld)kSDP*CmSucSAbBFK-N`rATd_P6%uU;wQ)DAsM@!meLY>FFsyp(>emw6%ea( zbPj9S*Lb(HYsE6N8V&}W+THJb_kwn9$g@JrGmc-Tf2E68qjTVOLr87U-HQ66c^P!M zZjxE*Xr&@p1@TmY(U*vr4^kg|K-LMokFL1wYU{yr64_DXEZmKc?2tL{e)sX)%=dob z+}CfQcE0_SDSzF*Yeqm&-Quduj*HS{NmM*>ec;|%WdcGuYLD>|I+6dpMU&! ze*M?qfBs8<{kvZbhrV>s|A~0|{8zvD>ia*uznBp(U(ka;`}m)Jqv66iKTeN5V=(ne z37ErFIOq0MbK1#a(O6kAZgy|o!6jaFR(gn?j@x)+u7&FZZ&%;08G~#mP!Q1u@MLg> z5f9?-eM}yt;~I-~;}Y}g4)qOx;NraXf<1nFf4X&F=2yOu^z`-C?dkt(?_6Fj&#pQy z#I$XT(g|JFRW&RJPON4>*4}IF9xC_`I6tt~+G~-bJKaq^ItHgcz{fxnNrDeh{{e*r zAMrUc3hLOI7;qveIy0ak-`}n7bls{_it2C=lHolZZk^iq{PtdZt?&2qJzn@29Hm_v zf3r|2yHi%SAr3Y2Y}SIn(}p&tOo}Euyn3w05%4h-YNl&KK?6?^qr^fU*KUnb{|!Wm zQP7ygU1r5Bd5>OVXD#lKBeQfPn~Et7n2 ze9mEGuYvduo?2%%l5no%j-rYKJC4nif2tb*B=5aLY1Keps?aav7RMf^KSK3{;SOBR zvvNn^NOa`+t&H6=)->L<2C$jd81R2uXh1-_It5uX$^|-}^b*x4q&ZR$Q_<76*F&mi zd+o`1W`=L@k@unW*b`6C>5uU#)--%ItWL-ZX;d0axDc3`hBd-DI53dkxLNbKe>l{& z&6zwllX9)u(-eQvo;DGyh8VwH>WbkWs8NeMs!N+g6M>PK#Nuztr?2Bvw81?@kN7O9 z#El_nXSA{Q&Ry4WMMiRlEUTJ28n4m{;LVdo`)VsYrWEStwd1ldx8rWcoqL)Lp}B3M z=+%YF6k&mNRq&!sPhZCO0y*z1e-xZOg`jJ!ovmYwSZm`vEG%Vm_M#x8vlnvIx7LZ= z>OhMJ(>#EE1H~Mwlc<42)>+Ah_BN*AR)~-p3abp$M<1ol*30QDpZ;$DgUL{N`EAa(?Ujn=e0CFX)pOO`zYteyJ<;JJ%l@^Zf4hH(z=@f1;&$h0Q;_ zi_O9td06DE1X?I$_$#9qDbd#mRQgL-KN^(9S#a+z9fm7z6IYgQK;Bn4g1748^cSoj5L=4gntXkd=N(Yl2{)j{4rAIHk zc%^gYbA_*6d)5^C%I|%De{dG}zCV24F82R@nfva_&}}f%0g$ddNWi(-wn2hMcCN_|*)j~I z>~{$233A3nJIWR~<*ui?|he|}eeef;5zq{jA! zJeJgmpZ_0R)Bf@GbJ#+^`srgWAh{Z4)D@vkKrVMh^A}C_wWOd~+!LMVwkNPdg=o8L z(Pp$2Dr1uwfMxbx%J7MulT^21)~~j>&cf`#$jOjw!%B^9wt9@y*Usfq@ba08n*Qna zb6B8nzWxHDrhk6@f6~FR#V>;HW%kilu|h_DA1c;4C&=CnW4JK`5ecY+dZ0ZJ0OgDr zEk#D%(hsY~P&cWp*|yaodjXsx8@@!9y>(9za#$*Dq+^xKzLu-*RXqLRxVTC@(b&7< zrF(k0dlu&fAno;|wK8Ae6t8S_N$yqeB{`B}1$iB!ie*$cb|1Fao-TwNe~9-^0ewU3#b7EcQHaVOd-6Jc<6O?ISI)GV^(!~d;q?5~8|To>`ofKK z__BQQ#&b5aK7qsgOE)gHvc7!dvBUie71z1<=*R;m9ENrF`Go)L zig(SYAMP(dy!-U~;8m~Qxu5U#^7;O8*uSp)M))tUpF@@L7q6YeHubGfoq-$b^p~%l z?TzqX&*Db-Z!dBq{Ey2wLI?`y*bq-w_SJ$Gx*-iAQ>y~K@$-ux69u$sUd3x!i_jm?9bUAoGM4xeO4b*$J=IGn zl9b8an9JHd?C|I>BVNWhMM#`l?4(+dzP^~8r+VnEYXrVHh2PFXC0@1`1BFr zrnD&3dVpMUFlaHq2kI5R$Lxb5J^KI`$ML7d>xc?hl9E-qRU?PW(j`3lzDOVyYEud< zS<-oKY2r2uV&HhL?DO!vYd!t>Yk2a{^3w5pH_xHm|NWaUJJ6>R3c;ip{YrM=4E4by2J)k#U`!f!!E^oMtOy z3<6kVMeMl%(1Cb=*b@nYSNjFLj0t^sKknTB{5yUpe(FKodq>~CbN|7+_u>gG@)fV* zGr%xcyp2DqtjA-NtBaq%6I``(*d)Gif9o7Ji7(!Ip-tjTw=QiGvPNo3^P$$;EEo-Y zm)c?1(I5$JhdY0R8>2`~+cTt3&P+TBLqRT?JO}FLtaU16=#ixbGS6Ik5s=G$a1c-r zR$7?V8Ld7M?cGNL;#yNi8j>6!@X(>KDl8<%0;n?@9lv*~gFuNn{RGXX1D6C6e*~>G z8)J_H|D0MK)fZPq_k5S-mI(cE{RD50);$(~U{QIL5azZhJB zG9YmQ^VUhEAyCOsX8roD<%YRF%20Q?FgN!qgC@=APOaml|ITO+;k2j1EUfG6_2Q7bIeg zL!f%>1!e;&EFLv`-5WT|-TL;b%^>LJMYZa7PRShAw3@Oh!UH>Ut%6m0f8c8*MN<5T zb!fvU;QC;N>9STq#FW`Nw%F-EZ=J&eed~GmrSE_5uD|UCMDi&IDcq%aVznpk2j&}6Rggln3Am3w z0}8N-I2B%Loe|M61yE@oe}Wk2?p0;#yqqKwV}L9Th+vzvrx|NaDNx7`Uemn79!Sd% z_6XEINEohdaDg9;Cy8~A6_E>urA}pUIL46O{Mx4xG$`B;^t00pnJf33BrVwM_OHccH| z3Ern!46U(BAaquiRq3FB&!Y#%%SV*tp4)VZ*@YES-l+1J74p#w-=W&2R?Eq?))ff{ zIVtGyfo7X}bHU!6RFx;(Xnoebdw1o|1`J}$o-3^ljn+mW7;kkc(la)8U$~{ps?bex zA)(Rxh&4c4Ts&jhf9Yp%!4dMpG-{tyYliH7cytSMv|h_1A@3FY5VKO)0+?Jn`aio4 zUCOIuktutHAyfueZ~Vh41tgA;PCtM1Ij1VG*u%`YhwlIB7jEAE zp@$Fhj@)@)f8V~l^+B9|@#gJMJ=#M*^2T4f`5}Mr())iI|Ndj!t0VxOqs%r-53TSM zP@ffhlp+8|g<8@wniBwuFrTnqI&I71n-%|8qQ(RMte=bsf^tL$nI(l{-N~E!;LaHsI|Ibf3~?Xd+N1>8V=se}HWTAR|=D%v(9^`a~p zId>8Qe>;Zt2|Qq5RH*a;Rr0D~GhqU+Yqm8^lyF7@hfo&MJILm!@Xyzjy%Qjn>AtPb zS)y6VsXKvP;dc7QwR8Bg{PneS__F-XwdXv2zVAZQy-$C8?Zb}3u@9d9?%IdU#1G!{ z_t!o;+kf-lzxVd5Z@=qr{lwk3O@H8|0TSv@^tLWhJzuF3XUMSN5BVSk@{>$Vn(mqHzGsWcUj>(i8e+-IDk4DTAT>m z*sF{}I1D4QSLPBZd|S6gySV_hv9_|sM%KbHEDjrSq$pKH4jqVwETaS>Dnp{GI+wl| z3jiH5z*r20VOZKM%5z5G&`Cv$)|5I~e?K-6WC*5JO5_`{We(CINwrC>-AOi+JN0aJ zdIj4^G59KMjk!iaPa+*YLg<8JEzfQY2}A&*SUF<`V;Y05??A)SJ=dTzd?-jvT};=K znWZ4TN4$^drE)7Bva3j3%Hr;?GkKP92EfVf{Gv!aPxOuY$-% z5F)4=7^fBvUk7ApAsgHqn$i~|@peWfbYcf(0VyAH5bRV|!xmPds#JCDePIR!;58cygYlY%4`eAs}@%5Gz{HAXfz*J +type CallbackParams = Record +type ConsentParams = Record + +// OAuth callback function type +type TokenExchangeCallbackFunction = (options: any) => Promise + /** * Get OIDC configuration for Auth0 */ @@ -59,14 +60,14 @@ function parseJWT(token: string): DevCycleJWTClaims { * Handles the token exchange process for OAuth authentication with DevCycle/Auth0. * This function processes both authorization code and refresh token flows. */ -export async function tokenExchangeCallback( - options: TokenExchangeCallbackOptions, -): Promise | void> { - const { grantType, env } = options +export const tokenExchangeCallback: TokenExchangeCallbackFunction = async ( + options: any, +) => { + const { grantType, env, props } = options // During the Authorization Code Exchange, preserve token TTL from Auth0 if (grantType === 'authorization_code') { - const idToken = options.props.tokenSet.idToken + const idToken = props?.tokenSet?.idToken if (!idToken) { throw new Error('No ID token received from Auth0') } @@ -82,13 +83,13 @@ export async function tokenExchangeCallback( } return { - accessTokenTTL: options.props.tokenSet.accessTokenTTL, + accessTokenTTL: props.tokenSet.accessTokenTTL, newProps: { claims, tokenSet: { - accessToken: options.props.tokenSet.accessToken, - idToken: options.props.tokenSet.idToken, - refreshToken: options.props.tokenSet.refreshToken || '', + accessToken: props.tokenSet.accessToken, + idToken: props.tokenSet.idToken, + refreshToken: props.tokenSet.refreshToken || '', }, } as UserProps, } @@ -96,7 +97,7 @@ export async function tokenExchangeCallback( // Handle refresh token flow if (grantType === 'refresh_token') { - const auth0RefreshToken = options.props.tokenSet.refreshToken + const auth0RefreshToken = props?.tokenSet?.refreshToken if (!auth0RefreshToken) { throw new Error('No Auth0 refresh token found') } @@ -126,7 +127,7 @@ export async function tokenExchangeCallback( claims = parseJWT(refreshTokenResponse.id_token) } else { // Fall back to existing claims if no new ID token - claims = options.props.claims as DevCycleJWTClaims + claims = props.claims as DevCycleJWTClaims } // Return updated token set and claims @@ -137,8 +138,7 @@ export async function tokenExchangeCallback( tokenSet: { accessToken: refreshTokenResponse.access_token, idToken: - refreshTokenResponse.id_token || - options.props.tokenSet.idToken, + refreshTokenResponse.id_token || props.tokenSet.idToken, refreshToken: refreshTokenResponse.refresh_token || auth0RefreshToken, }, @@ -225,7 +225,6 @@ export function createAuthApp(): Hono<{ Bindings: Env }> { version: '1.0.0', auth0Domain: c.env.AUTH0_DOMAIN, apiBaseUrl: c.env.API_BASE_URL || 'https://api.devcycle.com', - hasDefaultProject: !!c.env.DEFAULT_PROJECT_KEY, }) }) diff --git a/mcp-worker/src/index.ts b/mcp-worker/src/index.ts index 3b57d899d..1898a3f8c 100644 --- a/mcp-worker/src/index.ts +++ b/mcp-worker/src/index.ts @@ -1,19 +1,241 @@ +import OAuthProvider from '@cloudflare/workers-oauth-provider' +import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js' +import { McpAgent } from 'agents/mcp' +import { createAuthApp, tokenExchangeCallback } from './auth' +import { WorkerApiClient } from './apiClient' +import { MCPToolRegistry, registerAllTools } from '../../dist/mcp/tools' +import type { UserProps, Env } from './types' + /** - * DevCycle MCP Cloudflare Worker Entry Point + * DevCycle MCP Server for Cloudflare Workers * - * This file re-exports the worker implementation from the main CLI package - * to maintain a clean separation between the worker package and the main package - * while allowing shared code and tooling. + * This class extends McpAgent to provide DevCycle feature flag management + * through the Model Context Protocol over Server-Sent Events (SSE). + * It integrates OAuth authentication, tool registry, and Worker-specific API client. */ +export class DevCycleMCP extends McpAgent< + Env, + Record, + UserProps +> { + // The MCP server instance that handles protocol communication + server = new McpServer({ + name: 'DevCycle CLI MCP Server', + version: '1.0.0', + }) -// Re-export the configured Cloudflare Worker from the main package -export { default } from '@devcycle/cli/dist/mcp/worker/index.js' + // Tool registry containing all DevCycle MCP tools + private registry = new MCPToolRegistry() -// Export types that might be useful for external consumers -export type { - UserProps, - Env, - DevCycleJWTClaims, -} from '@devcycle/cli/dist/mcp/worker/types.js' + // Worker-specific API client that uses OAuth tokens + private apiClient: WorkerApiClient + + /** + * Initialize the MCP server with tools and handlers + */ + async init() { + console.log('Initializing DevCycle MCP Worker', { + userId: this.getUserId(), + orgId: this.getOrgId(), + hasProject: this.hasProjectKey(), + }) + + // Initialize the Worker-specific API client with OAuth tokens + this.apiClient = new WorkerApiClient(this.props, this.env) + + // Register all tools from the shared registry + registerAllTools(this.registry) + + console.log( + `Registered ${this.registry.size()} MCP tools:`, + this.registry.getToolNames(), + ) + + // Add a debug tool to inspect user context + this.server.tool( + 'whoami', + 'Get the current DevCycle user details and context', + {}, + async () => { + try { + const userContext = this.apiClient.getUserContext() + return { + content: [ + { + type: 'text', + text: JSON.stringify( + { + message: + 'DevCycle MCP Server - User Context', + context: userContext, + serverInfo: { + name: 'DevCycle CLI MCP Server', + version: '1.0.0', + environment: + this.env.NODE_ENV || + 'production', + apiBaseUrl: + this.env.API_BASE_URL || + 'https://api.devcycle.com', + }, + }, + null, + 2, + ), + }, + ], + } + } catch (error) { + return { + content: [ + { + type: 'text', + text: `Error retrieving user context: ${error instanceof Error ? error.message : String(error)}`, + }, + ], + } + } + }, + ) + + // Dynamically create MCP protocol handlers for each registered tool + for (const tool of this.registry.getAll()) { + // @ts-expect-error - MCP SDK type compatibility issues with tool registration + this.server.tool( + tool.name, + tool.description, + tool.inputSchema, + async (args: any) => { + try { + console.log(`Executing tool: ${tool.name}`, { + args, + userId: this.getUserId(), + }) + + // Execute tool with Worker-specific API client that uses OAuth tokens + const result = await this.registry.execute( + tool.name, + args, + this.apiClient, + ) + + // Format response according to MCP protocol expectations + // Check if result has dashboardLink (from executeWithDashboardLink) + let responseText: string + if ( + result && + typeof result === 'object' && + 'result' in result && + 'dashboardLink' in result + ) { + responseText = JSON.stringify( + { + data: result.result, + dashboardLink: result.dashboardLink, + }, + null, + 2, + ) + } else { + responseText = JSON.stringify(result, null, 2) + } + + return { + content: [ + { + type: 'text', + text: responseText, + }, + ], + } + } catch (error) { + console.error(`Tool execution error: ${tool.name}`, { + error: + error instanceof Error + ? error.message + : String(error), + args, + userId: this.getUserId(), + }) + + // Standardized error handling across all tools + const errorMessage = + error instanceof Error + ? error.message + : String(error) + return { + content: [ + { + type: 'text', + text: `Error executing ${tool.name}: ${errorMessage}`, + }, + ], + } + } + }, + ) + } + + console.log('DevCycle MCP Worker initialization completed') + } + + /** + * Get user ID from claims for logging + */ + private getUserId(): string { + const claims = this.props.claims as any + return claims?.sub || claims?.email || 'unknown' + } + + /** + * Get organization ID from claims + */ + private getOrgId(): string { + return (this.props.claims as any)?.org_id || 'unknown' + } + + /** + * Check if user has project key available + */ + private hasProjectKey(): boolean { + try { + this.apiClient.getUserContext() + return true + } catch { + return false + } + } +} + +/** + * Create and configure the main Cloudflare Worker export + * + * This sets up the OAuth Provider with the MCP server mounted on the /sse endpoint + * and includes all the necessary authentication and routing handlers. + */ +function createWorker() { + // Initialize the Hono app with OAuth routes + const authApp = createAuthApp() + + // Create the OAuth Provider with MCP server integration + return new OAuthProvider({ + // Mount the MCP server on the /sse endpoint for Server-Sent Events communication + apiHandler: DevCycleMCP.mount('/sse') as any, + apiRoute: '/sse', + + // OAuth endpoint configuration + authorizeEndpoint: '/authorize', + clientRegistrationEndpoint: '/signup', + tokenEndpoint: '/token', + + // Auth app handles all OAuth-related routes + // @ts-expect-error - Type compatibility with OAuth provider + defaultHandler: authApp, + + // Token exchange callback for handling OAuth token flows + tokenExchangeCallback, + }) +} -export { DevCycleMCP } from '@devcycle/cli/dist/mcp/worker/index.js' +// Export the configured Worker +export default createWorker() diff --git a/src/mcp/worker/types.ts b/mcp-worker/src/types.ts similarity index 97% rename from src/mcp/worker/types.ts rename to mcp-worker/src/types.ts index 812733c1c..bbd9850fe 100644 --- a/src/mcp/worker/types.ts +++ b/mcp-worker/src/types.ts @@ -24,7 +24,6 @@ export interface Env { // DevCycle API configuration API_BASE_URL?: string - DEFAULT_PROJECT_KEY?: string // Auth0 configuration AUTH0_DOMAIN: string diff --git a/mcp-worker/tsconfig.json b/mcp-worker/tsconfig.json index f5ee835dd..5d885f968 100644 --- a/mcp-worker/tsconfig.json +++ b/mcp-worker/tsconfig.json @@ -20,8 +20,7 @@ "sourceMap": true }, "include": [ - "src/**/*", - "../src/mcp/worker/**/*" + "src/**/*" ], "exclude": [ "node_modules", diff --git a/mcp-worker/wrangler.toml b/mcp-worker/wrangler.toml index 97f58d359..be310d6cb 100644 --- a/mcp-worker/wrangler.toml +++ b/mcp-worker/wrangler.toml @@ -25,15 +25,15 @@ API_BASE_URL = "https://api.devcycle.com" AUTH0_DOMAIN = "auth.devcycle.com" AUTH0_AUDIENCE = "https://api.devcycle.com/" AUTH0_SCOPE = "openid profile email offline_access" -# DEFAULT_PROJECT_KEY = "" # Optional: Set a default project for single-project deployments + # Secrets (set via: wrangler secret put ) # AUTH0_CLIENT_ID # AUTH0_CLIENT_SECRET -# AI binding for future features -[ai] -binding = "AI" +# AI binding for future features (not currently used) +# [ai] +# binding = "AI" # Observability [observability] diff --git a/mcp-worker/yarn.lock b/mcp-worker/yarn.lock index b580e9df2..4a727c6f5 100644 --- a/mcp-worker/yarn.lock +++ b/mcp-worker/yarn.lock @@ -124,7 +124,7 @@ __metadata: languageName: node linkType: hard -"@cloudflare/workers-types@npm:^4.20250311.0": +"@cloudflare/workers-types@npm:^4.20250311.0, @cloudflare/workers-types@npm:^4.20250726.0": version: 4.20250726.0 resolution: "@cloudflare/workers-types@npm:4.20250726.0" checksum: 10c0/91c708039cf51bbf6d46b1052508c3c308c425b624281fbd26152e967bcff6d92b9946621fea1fcf0538188d96c0280754b5bb1ca1f003675adb8a4f4b7e44de @@ -145,13 +145,14 @@ __metadata: resolution: "@devcycle/mcp-worker@workspace:." dependencies: "@cloudflare/workers-oauth-provider": "npm:^0.0.5" + "@cloudflare/workers-types": "npm:^4.20250726.0" "@modelcontextprotocol/sdk": "npm:^1.15.0" - "@types/node": "npm:^24.0.10" + "@types/node": "npm:^18.19.68" agents: "npm:^0.0.100" hono: "npm:^4.8.4" jose: "npm:^6.0.11" oauth4webapi: "npm:^3.5.5" - typescript: "npm:^5.8.3" + typescript: "npm:^5.7.2" wrangler: "npm:^4.22.0" zod: "npm:^3.24.2" languageName: unknown @@ -667,12 +668,12 @@ __metadata: languageName: node linkType: hard -"@types/node@npm:^24.0.10": - version: 24.1.0 - resolution: "@types/node@npm:24.1.0" +"@types/node@npm:^18.19.68": + version: 18.19.120 + resolution: "@types/node@npm:18.19.120" dependencies: - undici-types: "npm:~7.8.0" - checksum: 10c0/6c4686bc144f6ce7bffd4cadc3e1196e2217c1da4c639c637213719c8a3ee58b6c596b994befcbffeacd9d9eb0c3bff6529d2bc27da5d1cb9d58b1da0056f9f4 + undici-types: "npm:~5.26.4" + checksum: 10c0/fc436b93a3c9367b69d11a1c5d70cc923df6ea60141dd508ce2a248160c3bf8a04c658548a59df8ab9148b68bd58954fb603917baab3e2bc9da567f655534e5a languageName: node linkType: hard @@ -2563,7 +2564,7 @@ __metadata: languageName: node linkType: hard -"typescript@npm:^5.8.3": +"typescript@npm:^5.7.2": version: 5.8.3 resolution: "typescript@npm:5.8.3" bin: @@ -2573,7 +2574,7 @@ __metadata: languageName: node linkType: hard -"typescript@patch:typescript@npm%3A^5.8.3#optional!builtin": +"typescript@patch:typescript@npm%3A^5.7.2#optional!builtin": version: 5.8.3 resolution: "typescript@patch:typescript@npm%3A5.8.3#optional!builtin::version=5.8.3&hash=5786d5" bin: @@ -2590,10 +2591,10 @@ __metadata: languageName: node linkType: hard -"undici-types@npm:~7.8.0": - version: 7.8.0 - resolution: "undici-types@npm:7.8.0" - checksum: 10c0/9d9d246d1dc32f318d46116efe3cfca5a72d4f16828febc1918d94e58f6ffcf39c158aa28bf5b4fc52f410446bc7858f35151367bd7a49f21746cab6497b709b +"undici-types@npm:~5.26.4": + version: 5.26.5 + resolution: "undici-types@npm:5.26.5" + checksum: 10c0/bb673d7876c2d411b6eb6c560e0c571eef4a01c1c19925175d16e3a30c4c428181fb8d7ae802a261f283e4166a0ac435e2f505743aa9e45d893f9a3df017b501 languageName: node linkType: hard diff --git a/src/mcp/worker/index.ts b/src/mcp/worker/index.ts deleted file mode 100644 index 162997237..000000000 --- a/src/mcp/worker/index.ts +++ /dev/null @@ -1,244 +0,0 @@ -import OAuthProvider, { - type OAuthHelpers, -} from '@cloudflare/workers-oauth-provider' -import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js' -import { McpAgent } from 'agents/mcp' -import { Hono } from 'hono' -import { createAuthApp, tokenExchangeCallback } from './auth' -import { WorkerApiClient } from './apiClient' -import { MCPToolRegistry, registerAllTools } from '../tools' -import type { UserProps, Env } from './types' - -/** - * DevCycle MCP Server for Cloudflare Workers - * - * This class extends McpAgent to provide DevCycle feature flag management - * through the Model Context Protocol over Server-Sent Events (SSE). - * It integrates OAuth authentication, tool registry, and Worker-specific API client. - */ -export class DevCycleMCP extends McpAgent< - Env, - Record, - UserProps -> { - // The MCP server instance that handles protocol communication - // @ts-ignore - Type compatibility issue with MCP SDK versions - server = new McpServer({ - name: 'DevCycle CLI MCP Server', - version: '1.0.0', - }) - - // Tool registry containing all DevCycle MCP tools - private registry = new MCPToolRegistry() - - // Worker-specific API client that uses OAuth tokens - private apiClient: WorkerApiClient - - /** - * Initialize the MCP server with tools and handlers - */ - async init() { - console.log('Initializing DevCycle MCP Worker', { - userId: this.getUserId(), - orgId: this.getOrgId(), - hasProject: this.hasProjectKey(), - }) - - // Initialize the Worker-specific API client with OAuth tokens - this.apiClient = new WorkerApiClient(this.props, this.env) - - // Register all tools from the shared registry - registerAllTools(this.registry) - - console.log( - `Registered ${this.registry.size()} MCP tools:`, - this.registry.getToolNames(), - ) - - // Add a debug tool to inspect user context - this.server.tool( - 'whoami', - 'Get the current DevCycle user details and context', - {}, - async () => { - try { - const userContext = this.apiClient.getUserContext() - return { - content: [ - { - type: 'text', - text: JSON.stringify( - { - message: - 'DevCycle MCP Server - User Context', - context: userContext, - serverInfo: { - name: 'DevCycle CLI MCP Server', - version: '1.0.0', - environment: - this.env.NODE_ENV || - 'production', - apiBaseUrl: - this.env.API_BASE_URL || - 'https://api.devcycle.com', - }, - }, - null, - 2, - ), - }, - ], - } - } catch (error) { - return { - content: [ - { - type: 'text', - text: `Error retrieving user context: ${error instanceof Error ? error.message : String(error)}`, - }, - ], - } - } - }, - ) - - // Dynamically create MCP protocol handlers for each registered tool - for (const tool of this.registry.getAll()) { - this.server.tool( - tool.name, - tool.description, - tool.inputSchema, - async (args) => { - try { - console.log(`Executing tool: ${tool.name}`, { - args, - userId: this.getUserId(), - }) - - // Execute tool with Worker-specific API client that uses OAuth tokens - const result = await this.registry.execute( - tool.name, - args, - this.apiClient, - ) - - // Format response according to MCP protocol expectations - // Check if result has dashboardLink (from executeWithDashboardLink) - let responseText: string - if ( - result && - typeof result === 'object' && - 'result' in result && - 'dashboardLink' in result - ) { - responseText = JSON.stringify( - { - data: result.result, - dashboardLink: result.dashboardLink, - }, - null, - 2, - ) - } else { - responseText = JSON.stringify(result, null, 2) - } - - return { - content: [ - { - type: 'text', - text: responseText, - }, - ], - } - } catch (error) { - console.error(`Tool execution error: ${tool.name}`, { - error: - error instanceof Error - ? error.message - : String(error), - args, - userId: this.getUserId(), - }) - - // Standardized error handling across all tools - const errorMessage = - error instanceof Error - ? error.message - : String(error) - return { - content: [ - { - type: 'text', - text: `Error executing ${tool.name}: ${errorMessage}`, - }, - ], - } - } - }, - ) - } - - console.log('DevCycle MCP Worker initialization completed') - } - - /** - * Get user ID from claims for logging - */ - private getUserId(): string { - return this.props.claims?.sub || this.props.claims?.email || 'unknown' - } - - /** - * Get organization ID from claims - */ - private getOrgId(): string { - return (this.props.claims as any)?.org_id || 'unknown' - } - - /** - * Check if user has project key available - */ - private hasProjectKey(): boolean { - try { - this.apiClient.getUserContext() - return true - } catch { - return false - } - } -} - -/** - * Create and configure the main Cloudflare Worker export - * - * This sets up the OAuth Provider with the MCP server mounted on the /sse endpoint - * and includes all the necessary authentication and routing handlers. - */ -function createWorker() { - // Initialize the Hono app with OAuth routes - const authApp = createAuthApp() - - // Create the OAuth Provider with MCP server integration - return new OAuthProvider({ - // Mount the MCP server on the /sse endpoint for Server-Sent Events communication - // @ts-expect-error - Type compatibility with OAuth provider and MCP agent - apiHandler: DevCycleMCP.mount('/sse'), - apiRoute: '/sse', - - // OAuth endpoint configuration - authorizeEndpoint: '/authorize', - clientRegistrationEndpoint: '/signup', - tokenEndpoint: '/token', - - // Auth app handles all OAuth-related routes - // @ts-expect-error - Type compatibility with OAuth provider - defaultHandler: authApp, - - // Token exchange callback for handling OAuth token flows - tokenExchangeCallback, - }) -} - -// Export the configured Worker -export default createWorker() diff --git a/tsconfig.json b/tsconfig.json index ff852e68c..f9bc06b72 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -24,5 +24,5 @@ "tsBuildInfoFile": "./dist/.tsbuildinfo" }, "include": ["src/**/*"], - "exclude": ["src/**/*.test.ts", "src/mcp/worker/**/*", "dist", "node_modules", "bin"] + "exclude": ["src/**/*.test.ts", "dist", "node_modules", "bin"] } diff --git a/tsconfig.mcp.json b/tsconfig.mcp.json index c30f7f492..9f678b627 100644 --- a/tsconfig.mcp.json +++ b/tsconfig.mcp.json @@ -2,6 +2,7 @@ "extends": "./tsconfig.json", "compilerOptions": { "outDir": "./dist/mcp-shared", + "rootDir": "./src", "declaration": true, "declarationMap": true, "sourceMap": true @@ -9,7 +10,6 @@ "include": [ "src/mcp/tools/**/*", "src/mcp/api/interface.ts", - "src/mcp/worker/**/*", "src/api/**/*" ], "exclude": [ From 2e038b5da90cc9a15a1659fa43f00cfff7d84bbe Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Mon, 28 Jul 2025 13:26:44 -0400 Subject: [PATCH 08/31] feat: MCP Worker auth mostly working --- mcp-worker/.gitignore | 1 + mcp-worker/.yarn/install-state.gz | Bin 235343 -> 235210 bytes mcp-worker/src/auth.ts | 492 +- mcp-worker/src/consentScreen.ts | 200 + mcp-worker/src/index.ts | 55 +- mcp-worker/tsconfig.json | 5 +- mcp-worker/worker-configuration.d.ts | 7370 ++++++++++++++++++++++++++ mcp-worker/wrangler.toml | 4 +- 8 files changed, 7943 insertions(+), 184 deletions(-) create mode 100644 mcp-worker/src/consentScreen.ts create mode 100644 mcp-worker/worker-configuration.d.ts diff --git a/mcp-worker/.gitignore b/mcp-worker/.gitignore index 6494d7c5d..6fe79c1a2 100644 --- a/mcp-worker/.gitignore +++ b/mcp-worker/.gitignore @@ -10,6 +10,7 @@ node_modules/ .env.local .env.production .env.development +.dev.vars # Logs *.log diff --git a/mcp-worker/.yarn/install-state.gz b/mcp-worker/.yarn/install-state.gz index 095e39f5ace364435f9aaa7d5242d7fd891039b0..68cd52708b95b18e4e50eaa8e60716501e7b2e02 100644 GIT binary patch delta 176081 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℞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 ~Dyu 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 uBRiG{Vi$2`4vCL-OFS^ej6i`j5gJlvFns$bSo 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�IM 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 R@aKQve*lL&7lb8I3jku9xzPXs delta 176237 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ð)FZ~upDSa+Uih~x8P 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 z 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

U`Edq)?;6d>JE1#&jp_ndbU8>Y;oT;PU1c> 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%0A^!zC<8Nu4~|I?uwX5e zh7)(!C5C5?rm!&2E%Q3ST83ni!>K2epjNx9cCtA!%54sl#RPgHVPcuYUna8TQ?EX9vfSe zdH=L{XiM>v`O9k`3L8H}m;2lA-U6h|ujnieeHEWx8y?!4f6-pM3^Oe+31<3rOY0L$ z>oeMG0$Qf8ifEduR^T6sxqrA#qi}XAB`?^YtuM@;YEG_(jW;UVv5*uh+(EvL3^A!n zh-t4G@#v*&@gy9xOi#6ChSYhm&b&&VUVQf(C!3FGED9SVX<3ZCxiq9jUqOh_J(R2x*uBfIs02|SNpMl(^u9tkJ|SnLY{dca~g&mn6Ca4vn$Wq-N%TPMeGv;6kSbM8Lhbgt=MyRV#l&{5dd!QJnkd_Zn|@|oW|`RHu_&R0Kv z^Y!}==Di=dd*8qRhkV{Ud;IBbdb*~G2e^JEh68TU72r!|H?^pJ^d=N*3qygZG=W>5 zSVU1Odrr;ZA?c;J6n}{ZO!SffVZ|)8XE!XS+Vku>feZBBkY~5t*>8U9*}c2(yyNTp z9^bvc&c5rrzv1TVTL-P1)Rv{*-NCef< z+C+K}Dma4R9?^OTB(1${S#>q9xe(UJbEV;P1<}GN2pdpELw}0{F?VaEmI#}nd(_OF z9EESGHfWV80Dg?6Y`&0kwhfEjns51~8DXCrq9IaCj&OJv&#IGCU4sRf5NRMiy23Cl zr6=Xy-LdI}qD5;;m8@=y2-3R)EO{i0vPCq~CPBGK&UKP3ra7rb$$e%JmK1}p#8#NI zC-fv@!bb?5uz!y+qZ&g3;XpZN4)4yG#-Qul(6F2{Mx)ebQ}Cdwn2sSmQbKN~%-X!B z%q3OGu3BE2aQ*<#y4BSp*ExHRQegCn1|TrDEJ4)>8KqFe89W7IVOP(Na|ezU_*S64 zBwpZ+Wr4m!UFzV-*1BgxC$>=}WK=;8f|bg$+rU-GDp{x2Ixqu5)Dw#%oH(@}>XXn- zCI!#Td9wkTrBzxhg{&>k2sm1?U2&Cw#I&Lynro2Jpp4UqQV|}F7k(e;7n19wkT&nU R@}uAKKL~_ub&MrZ3jn5@z^woP diff --git a/mcp-worker/src/auth.ts b/mcp-worker/src/auth.ts index e910e9939..af8b79d8c 100644 --- a/mcp-worker/src/auth.ts +++ b/mcp-worker/src/auth.ts @@ -1,103 +1,357 @@ -import * as oauth from 'oauth4webapi' +import { env } from 'cloudflare:workers' import { Hono } from 'hono' +import { getCookie, setCookie } from 'hono/cookie' +import * as oauth from 'oauth4webapi' import type { UserProps, Env, DevCycleJWTClaims } from './types' +import { OAuthHelpers } from '@cloudflare/workers-oauth-provider' +import type { + AuthRequest, + TokenExchangeCallbackOptions, + TokenExchangeCallbackResult, +} from '@cloudflare/workers-oauth-provider' +import { renderConsentScreen } from './consentScreen' -// Define OAuth parameter types locally since they're not exported correctly -type AuthorizeParams = Record -type CallbackParams = Record -type ConsentParams = Record - -// OAuth callback function type -type TokenExchangeCallbackFunction = (options: any) => Promise +type Auth0AuthRequest = { + mcpAuthRequest: AuthRequest + codeVerifier: string + codeChallenge: string + nonce: string + transactionState: string + consentToken: string +} -/** - * Get OIDC configuration for Auth0 - */ -async function getOidcConfig(options: { +export async function getOidcConfig({ + issuer, + client_id, + client_secret, +}: { + issuer: string client_id: string client_secret: string - issuer: string }) { - const as = await oauth - .discoveryRequest(new URL(options.issuer)) - .then((response) => - oauth.processDiscoveryResponse(new URL(options.issuer), response), - ) - - const client: oauth.Client = { - client_id: options.client_id, - token_endpoint_auth_method: 'client_secret_basic', + // Validate required parameters + if (!issuer) { + throw new Error('AUTH0_DOMAIN is required but not set') + } + if (!client_id) { + throw new Error('AUTH0_CLIENT_ID is required but not set') + } + if (!client_secret) { + throw new Error('AUTH0_CLIENT_SECRET is required but not set') } - const clientAuth = oauth.ClientSecretBasic(options.client_secret) - + const response = await oauth.discoveryRequest(new URL(issuer), { + algorithm: 'oidc', + }) + console.log('Auth0 Discovery Response:', JSON.stringify(response)) + const as = await oauth.processDiscoveryResponse(new URL(issuer), response) + const client: oauth.Client = { client_id } + const clientAuth = oauth.ClientSecretPost(client_secret) return { as, client, clientAuth } } /** - * Parse JWT token to extract claims + * OAuth Authorization Endpoint + * + * This route initiates the Authorization Code Flow when a user wants to log in. + * It creates a random state parameter to prevent CSRF attacks and stores the + * original request information in a state-specific cookie for later retrieval. + * Then it shows a consent screen before redirecting to Auth0. */ -function parseJWT(token: string): DevCycleJWTClaims { - try { - const parts = token.split('.') - if (parts.length !== 3) { - throw new Error('Invalid JWT format') - } +export async function authorize( + c: any & { env: Env & { OAUTH_PROVIDER: OAuthHelpers } }, +) { + const mcpClientAuthRequest = await c.env.OAUTH_PROVIDER.parseAuthRequest( + c.req.raw, + ) + if (!mcpClientAuthRequest.clientId) { + return c.text('Invalid request', 400) + } - const payload = parts[1] - const decoded = JSON.parse( - atob(payload.replace(/-/g, '+').replace(/_/g, '/')), - ) - return decoded as DevCycleJWTClaims - } catch (error) { - throw new Error(`Failed to parse JWT: ${error}`) + const client = await c.env.OAUTH_PROVIDER.lookupClient( + mcpClientAuthRequest.clientId, + ) + if (!client) { + return c.text('Invalid client', 400) } + + // Generate all that is needed for the Auth0 auth request + const codeVerifier = oauth.generateRandomCodeVerifier() + const transactionState = oauth.generateRandomState() + const consentToken = oauth.generateRandomState() // For CSRF protection on consent form + + // We will persist everything in a cookie. + const auth0AuthRequest: Auth0AuthRequest = { + codeChallenge: await oauth.calculatePKCECodeChallenge(codeVerifier), + codeVerifier, + consentToken, + mcpAuthRequest: mcpClientAuthRequest, + nonce: oauth.generateRandomNonce(), + transactionState, + } + + // Store the auth request in a transaction-specific cookie + const cookieName = `auth0_req_${transactionState}` + setCookie(c, cookieName, btoa(JSON.stringify(auth0AuthRequest)), { + httpOnly: true, + maxAge: 60 * 60 * 1, // 1 hour + path: '/', + sameSite: c.env.NODE_ENV !== 'development' ? 'none' : 'lax', + secure: c.env.NODE_ENV !== 'development', + }) + + // Extract client information for the consent screen + const clientName = client.clientName || client.clientId + const clientLogo = client.logoUri || '' // No default logo + const clientUri = client.clientUri || '#' + const requestedScopes = (c.env.AUTH0_SCOPE || '').split(' ') + + // Render the consent screen with CSRF protection + return c.html( + renderConsentScreen({ + clientLogo, + clientName, + clientUri, + consentToken, + redirectUri: mcpClientAuthRequest.redirectUri, + requestedScopes, + transactionState, + }), + ) } /** - * Token Exchange Callback + * Consent Confirmation Endpoint * - * Handles the token exchange process for OAuth authentication with DevCycle/Auth0. - * This function processes both authorization code and refresh token flows. + * This route handles the consent confirmation before redirecting to Auth0 */ -export const tokenExchangeCallback: TokenExchangeCallbackFunction = async ( - options: any, -) => { - const { grantType, env, props } = options - - // During the Authorization Code Exchange, preserve token TTL from Auth0 - if (grantType === 'authorization_code') { - const idToken = props?.tokenSet?.idToken - if (!idToken) { - throw new Error('No ID token received from Auth0') - } +export async function confirmConsent(c: any) { + // Get form data + const formData = await c.req.formData() + console.log('Confirming consent') + console.log(JSON.stringify(formData)) - // Extract claims from the ID token - const claims = parseJWT(idToken) + const transactionState = formData.get('transaction_state') as string + const consentToken = formData.get('consent_token') as string + const consentAction = formData.get('consent_action') as string - // Validate that we have the necessary DevCycle context - if (!claims.org_id) { - throw new Error( - 'DevCycle organization ID not found in token claims', + // Validate the transaction state + if (!transactionState) { + return c.text('Invalid transaction state', 400) + } + + // Get the transaction-specific cookie + const cookieName = `auth0_req_${transactionState}` + const auth0AuthRequestCookie = getCookie(c, cookieName) + if (!auth0AuthRequestCookie) { + return c.text('Invalid or expired transaction', 400) + } + + // Parse the Auth0 auth request from the cookie + console.log( + 'Auth0 Authorization Server - Transaction State Cookie:', + auth0AuthRequestCookie, + ) + const auth0AuthRequest = JSON.parse( + atob(auth0AuthRequestCookie), + ) as Auth0AuthRequest + + // Validate the CSRF token + if (auth0AuthRequest.consentToken !== consentToken) { + return c.text('Invalid consent token', 403) + } + + // Handle user denial + if (consentAction !== 'approve') { + // Parse the MCP client auth request to get the original redirect URI + const redirectUri = new URL(auth0AuthRequest.mcpAuthRequest.redirectUri) + + // Add error parameters to the redirect URI + redirectUri.searchParams.set('error', 'access_denied') + redirectUri.searchParams.set( + 'error_description', + 'User denied the request', + ) + if (auth0AuthRequest.mcpAuthRequest.state) { + redirectUri.searchParams.set( + 'state', + auth0AuthRequest.mcpAuthRequest.state, ) } + // Clear the transaction cookie + setCookie(c, cookieName, '', { + maxAge: 0, + path: '/', + }) + + return c.redirect(redirectUri.toString()) + } + + const { as } = await getOidcConfig({ + client_id: c.env.AUTH0_CLIENT_ID, + client_secret: c.env.AUTH0_CLIENT_SECRET, + issuer: `https://${c.env.AUTH0_DOMAIN}/`, + }) + + console.log( + 'Auth0 Authorization Server - Discovery Information:', + JSON.stringify(as), + ) + + // Redirect to Auth0's authorization endpoint + const authorizationUrl = new URL(as.authorization_endpoint!) + authorizationUrl.searchParams.set('client_id', c.env.AUTH0_CLIENT_ID) + authorizationUrl.searchParams.set( + 'redirect_uri', + new URL('/callback', c.req.url).href, + ) + authorizationUrl.searchParams.set('response_type', 'code') + authorizationUrl.searchParams.set('audience', c.env.AUTH0_AUDIENCE) + authorizationUrl.searchParams.set('scope', c.env.AUTH0_SCOPE) + authorizationUrl.searchParams.set( + 'code_challenge', + auth0AuthRequest.codeChallenge, + ) + authorizationUrl.searchParams.set('code_challenge_method', 'S256') + authorizationUrl.searchParams.set('nonce', auth0AuthRequest.nonce) + authorizationUrl.searchParams.set('state', transactionState) + + return c.redirect(authorizationUrl.href) +} + +/** + * OAuth Callback Endpoint + * + * This route handles the callback from Auth0 after user authentication. + * It exchanges the authorization code for tokens and completes the + * authorization process. + */ +export async function callback( + c: any & { env: Env & { OAUTH_PROVIDER: OAuthHelpers } }, +) { + // Parse the state parameter to extract transaction state and Auth0 state + const stateParam = c.req.query('state') as string + if (!stateParam) { + return c.text('Invalid state parameter', 400) + } + + // Parse the Auth0 auth request from the transaction-specific cookie + const cookieName = `auth0_req_${stateParam}` + const auth0AuthRequestCookie = getCookie(c, cookieName) + if (!auth0AuthRequestCookie) { + return c.text('Invalid transaction state or session expired', 400) + } + + const auth0AuthRequest = JSON.parse( + atob(auth0AuthRequestCookie), + ) as Auth0AuthRequest + + // Clear the transaction cookie as it's no longer needed + setCookie(c, cookieName, '', { + maxAge: 0, + path: '/', + }) + + console.log( + 'Auth0 Authorization Server - Transaction State:', + auth0AuthRequest, + ) + + const { as, client, clientAuth } = await getOidcConfig({ + client_id: c.env.AUTH0_CLIENT_ID, + client_secret: c.env.AUTH0_CLIENT_SECRET, + issuer: `https://${c.env.AUTH0_DOMAIN}/`, + }) + + console.log( + 'Auth0 Authorization Server - Discovery Information:', + JSON.stringify(as), + JSON.stringify(clientAuth), + ) + + // Perform the Code Exchange + const params = oauth.validateAuthResponse( + as, + client, + new URL(c.req.url), + auth0AuthRequest.transactionState, + ) + + console.log('Response parameters from Auth0:', params) + + const response = await oauth.authorizationCodeGrantRequest( + as, + client, + clientAuth, + params, + new URL('/callback', c.req.url).href, + auth0AuthRequest.codeVerifier, + ) + + console.log('Response from Auth0 callback:', response) + + // Process the response + const result = await oauth.processAuthorizationCodeResponse( + as, + client, + response, + { + expectedNonce: auth0AuthRequest.nonce, + requireIdToken: true, + }, + ) + + // Get the claims from the id_token + const claims = oauth.getValidatedIdTokenClaims(result) + if (!claims) { + return c.text('Received invalid id_token from Auth0', 400) + } + + // Complete the authorization + const { redirectTo } = await c.env.OAUTH_PROVIDER.completeAuthorization({ + metadata: { + label: claims.name || claims.email || claims.sub, + }, + props: { + claims: claims, + tokenSet: { + accessToken: result.access_token, + accessTokenTTL: result.expires_in, + idToken: result.id_token, + refreshToken: result.refresh_token, + }, + } as UserProps, + request: auth0AuthRequest.mcpAuthRequest, + scope: auth0AuthRequest.mcpAuthRequest.scope, + userId: claims.sub!, + }) + + return Response.redirect(redirectTo) +} + +/** + * Token Exchange Callback + * + * This function handles the token exchange callback for the CloudflareOAuth Provider + * and allows us to then interact with the Upstream IdP (your Auth0 tenant) + */ +export async function tokenExchangeCallback( + options: TokenExchangeCallbackOptions, +): Promise { + // During the Authorization Code Exchange, we want to make sure that the Access Token issued + // by the MCP Server has the same TTL as the one issued by Auth0. + if (options.grantType === 'authorization_code') { return { - accessTokenTTL: props.tokenSet.accessTokenTTL, + accessTokenTTL: options.props.tokenSet.accessTokenTTL, newProps: { - claims, - tokenSet: { - accessToken: props.tokenSet.accessToken, - idToken: props.tokenSet.idToken, - refreshToken: props.tokenSet.refreshToken || '', - }, - } as UserProps, + ...options.props, + }, } } - // Handle refresh token flow - if (grantType === 'refresh_token') { - const auth0RefreshToken = props?.tokenSet?.refreshToken + if (options.grantType === 'refresh_token') { + const auth0RefreshToken = options.props.tokenSet.refreshToken if (!auth0RefreshToken) { throw new Error('No Auth0 refresh token found') } @@ -108,115 +362,67 @@ export const tokenExchangeCallback: TokenExchangeCallbackFunction = async ( issuer: `https://${env.AUTH0_DOMAIN}/`, }) - // Perform the refresh token exchange with Auth0 + // Perform the refresh token exchange with Auth0. const response = await oauth.refreshTokenGrantRequest( as, client, clientAuth, auth0RefreshToken, ) + const refreshTokenResponse = await oauth.processRefreshTokenResponse( as, client, response, ) - // Extract claims from the new ID token - let claims: DevCycleJWTClaims - if (refreshTokenResponse.id_token) { - claims = parseJWT(refreshTokenResponse.id_token) - } else { - // Fall back to existing claims if no new ID token - claims = props.claims as DevCycleJWTClaims + // Get the claims from the id_token + const claims = oauth.getValidatedIdTokenClaims(refreshTokenResponse) + if (!claims) { + throw new Error('Received invalid id_token from Auth0') } - // Return updated token set and claims + // Store the new token set and claims. return { accessTokenTTL: refreshTokenResponse.expires_in, newProps: { - claims, + ...options.props, + claims: claims, tokenSet: { accessToken: refreshTokenResponse.access_token, - idToken: - refreshTokenResponse.id_token || props.tokenSet.idToken, + accessTokenTTL: refreshTokenResponse.expires_in, + idToken: refreshTokenResponse.id_token, refreshToken: refreshTokenResponse.refresh_token || auth0RefreshToken, }, - } as UserProps, + }, } } - // For other grant types, no special handling needed - return undefined + throw new Error(`Unsupported grant type: ${options.grantType}`) } /** - * Authorization endpoint handler - * Initiates the OAuth flow with DevCycle/Auth0 + * Create the Hono app with OAuth and utility routes */ -export async function authorize(c: any): Promise { - const params = c.req.query() as AuthorizeParams - - // Add DevCycle-specific scopes if not already present - const defaultScopes = ['openid', 'profile', 'email', 'offline_access'] - const requestedScopes = params.scope?.split(' ') || [] - const allScopes = [...new Set([...defaultScopes, ...requestedScopes])] - - // Forward to the OAuth provider with enhanced scopes - return c.env.OAUTH_PROVIDER.authorize({ - ...params, - scope: allScopes.join(' '), - }) -} - -/** - * OAuth callback handler - * Processes the callback from Auth0 after user authentication - */ -export async function callback(c: any): Promise { - const params = c.req.query() as CallbackParams - return c.env.OAUTH_PROVIDER.callback(params) -} - -/** - * Consent confirmation handler - * Handles user consent for the OAuth flow - */ -export async function confirmConsent(c: any): Promise { - const formData = await c.req.formData() - const params = Object.fromEntries(formData.entries()) as ConsentParams - return c.env.OAUTH_PROVIDER.confirmConsent(params) -} +export function createAuthApp(): Hono<{ + Bindings: Env & { OAUTH_PROVIDER: OAuthHelpers } +}> { + const app = new Hono<{ Bindings: Env & { OAUTH_PROVIDER: OAuthHelpers } }>() -/** - * Health check endpoint - */ -export function healthCheck() { - return new Response( - JSON.stringify({ - status: 'ok', - service: 'DevCycle MCP Server', - timestamp: new Date().toISOString(), - }), - { - headers: { 'Content-Type': 'application/json' }, - }, - ) -} - -/** - * Create the Hono app with OAuth routes - */ -export function createAuthApp(): Hono<{ Bindings: Env }> { - const app = new Hono<{ Bindings: Env }>() - - // OAuth flow endpoints + // OAuth routes - these are required for the OAuth flow app.get('/authorize', authorize) app.post('/authorize/consent', confirmConsent) app.get('/callback', callback) // Health check - app.get('/health', () => healthCheck()) + app.get('/health', (c) => { + return c.json({ + status: 'ok', + service: 'DevCycle MCP Server', + timestamp: new Date().toISOString(), + }) + }) // Info endpoint for debugging app.get('/info', (c) => { diff --git a/mcp-worker/src/consentScreen.ts b/mcp-worker/src/consentScreen.ts new file mode 100644 index 000000000..d6cdab7db --- /dev/null +++ b/mcp-worker/src/consentScreen.ts @@ -0,0 +1,200 @@ +import { html, raw } from 'hono/html' + +/** + * Renders the consent screen HTML + */ +export function renderConsentScreen({ + clientName, + clientLogo, + clientUri, + redirectUri, + requestedScopes, + transactionState, + consentToken, +}: { + clientName: string + clientLogo: string + clientUri: string + redirectUri: string + requestedScopes: string[] + transactionState: string + consentToken: string +}) { + return html` + + + Authorization Request + + + + +

+ + +

DevCycle MCP Server - Authorization Request

+ +
+ ${clientName} +

+ ${clientName} is requesting + permission to access the + DevCycle API using your account. + Please review the permissions before proceeding. +

+
+ +
+

+ By clicking "Allow Access", you authorize + ${clientName} to access the + following resources: +

+
    + ${raw( + requestedScopes + .map((scope) => `
  • ${scope}
    • `) + .join('\n'), + )} +
+
+ +
+

+ If you did not initiate the request coming from + ${clientName} + (${redirectUri}) or you do not trust this + application, you should deny access. +

+
+ +
+ + +
+ + +
+
+ +
+

+ You're signing in to a third-party application. Your + account information is never shared without your + permission. +

+
+
+ + ` +} diff --git a/mcp-worker/src/index.ts b/mcp-worker/src/index.ts index 1898a3f8c..c84a23061 100644 --- a/mcp-worker/src/index.ts +++ b/mcp-worker/src/index.ts @@ -3,7 +3,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js' import { McpAgent } from 'agents/mcp' import { createAuthApp, tokenExchangeCallback } from './auth' import { WorkerApiClient } from './apiClient' -import { MCPToolRegistry, registerAllTools } from '../../dist/mcp/tools' +import { MCPToolRegistry, registerAllTools } from '../../src/mcp/tools' import type { UserProps, Env } from './types' /** @@ -18,7 +18,6 @@ export class DevCycleMCP extends McpAgent< Record, UserProps > { - // The MCP server instance that handles protocol communication server = new McpServer({ name: 'DevCycle CLI MCP Server', version: '1.0.0', @@ -51,7 +50,7 @@ export class DevCycleMCP extends McpAgent< this.registry.getToolNames(), ) - // Add a debug tool to inspect user context + // Useful for debugging. This will show the current user's claims and the Auth0 tokens. this.server.tool( 'whoami', 'Get the current DevCycle user details and context', @@ -68,6 +67,7 @@ export class DevCycleMCP extends McpAgent< message: 'DevCycle MCP Server - User Context', context: userContext, + props: this.props, // Include full props for debugging like the example serverInfo: { name: 'DevCycle CLI MCP Server', version: '1.0.0', @@ -100,7 +100,7 @@ export class DevCycleMCP extends McpAgent< // Dynamically create MCP protocol handlers for each registered tool for (const tool of this.registry.getAll()) { - // @ts-expect-error - MCP SDK type compatibility issues with tool registration + // @ts-expect-error MCP SDK type compatibility issues with tool registration this.server.tool( tool.name, tool.description, @@ -167,7 +167,7 @@ export class DevCycleMCP extends McpAgent< content: [ { type: 'text', - text: `Error executing ${tool.name}: ${errorMessage}`, + text: `The call to ${tool.name} failed: ${errorMessage}`, }, ], } @@ -207,35 +207,16 @@ export class DevCycleMCP extends McpAgent< } } -/** - * Create and configure the main Cloudflare Worker export - * - * This sets up the OAuth Provider with the MCP server mounted on the /sse endpoint - * and includes all the necessary authentication and routing handlers. - */ -function createWorker() { - // Initialize the Hono app with OAuth routes - const authApp = createAuthApp() - - // Create the OAuth Provider with MCP server integration - return new OAuthProvider({ - // Mount the MCP server on the /sse endpoint for Server-Sent Events communication - apiHandler: DevCycleMCP.mount('/sse') as any, - apiRoute: '/sse', - - // OAuth endpoint configuration - authorizeEndpoint: '/authorize', - clientRegistrationEndpoint: '/signup', - tokenEndpoint: '/token', - - // Auth app handles all OAuth-related routes - // @ts-expect-error - Type compatibility with OAuth provider - defaultHandler: authApp, - - // Token exchange callback for handling OAuth token flows - tokenExchangeCallback, - }) -} - -// Export the configured Worker -export default createWorker() +// Initialize the Hono app with non-OAuth routes only +// Let the OAuth Provider handle OAuth routes (/authorize, /callback, etc.) automatically +const app = createAuthApp() + +export default new OAuthProvider({ + apiHandler: DevCycleMCP.mount('/sse'), + apiRoute: '/sse', + authorizeEndpoint: '/authorize', + clientRegistrationEndpoint: '/signup', + defaultHandler: app as any, + tokenEndpoint: '/token', + tokenExchangeCallback, +}) diff --git a/mcp-worker/tsconfig.json b/mcp-worker/tsconfig.json index 5d885f968..7c606ff13 100644 --- a/mcp-worker/tsconfig.json +++ b/mcp-worker/tsconfig.json @@ -2,7 +2,7 @@ "extends": "../tsconfig.json", "compilerOptions": { "outDir": "./dist", - "rootDir": "./src", + "rootDir": "../", "types": [ "@cloudflare/workers-types", "node" @@ -20,7 +20,8 @@ "sourceMap": true }, "include": [ - "src/**/*" + "src/**/*", + "../src/mcp/**/*" ], "exclude": [ "node_modules", diff --git a/mcp-worker/worker-configuration.d.ts b/mcp-worker/worker-configuration.d.ts new file mode 100644 index 000000000..611c8565d --- /dev/null +++ b/mcp-worker/worker-configuration.d.ts @@ -0,0 +1,7370 @@ +/* eslint-disable */ +// Generated by Wrangler by running `wrangler types` (hash: aaf1a93ae0904c253b1df9eb8e1bf827) +// Runtime types generated with workerd@1.20250712.0 2025-06-28 nodejs_compat +declare namespace Cloudflare { + interface Env { + OAUTH_KV: KVNamespace; + NODE_ENV: "production"; + API_BASE_URL: "https://api.devcycle.com"; + AUTH0_DOMAIN: "auth.devcycle.com"; + AUTH0_AUDIENCE: "https://api.devcycle.com/"; + AUTH0_SCOPE: "openid profile email offline_access"; + MCP_OBJECT: DurableObjectNamespace; + } +} +interface Env extends Cloudflare.Env {} +type StringifyValues> = { + [Binding in keyof EnvType]: EnvType[Binding] extends string ? EnvType[Binding] : string; +}; +declare namespace NodeJS { + interface ProcessEnv extends StringifyValues> {} +} + +// Begin runtime types +/*! ***************************************************************************** +Copyright (c) Cloudflare. All rights reserved. +Copyright (c) Microsoft Corporation. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ +/* eslint-disable */ +// noinspection JSUnusedGlobalSymbols +declare var onmessage: never; +/** + * An abnormal event (called an exception) which occurs as a result of calling a method or accessing a property of a web API. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException) + */ +declare class DOMException extends Error { + constructor(message?: string, name?: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/message) */ + readonly message: string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/name) */ + readonly name: string; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/code) + */ + readonly code: number; + static readonly INDEX_SIZE_ERR: number; + static readonly DOMSTRING_SIZE_ERR: number; + static readonly HIERARCHY_REQUEST_ERR: number; + static readonly WRONG_DOCUMENT_ERR: number; + static readonly INVALID_CHARACTER_ERR: number; + static readonly NO_DATA_ALLOWED_ERR: number; + static readonly NO_MODIFICATION_ALLOWED_ERR: number; + static readonly NOT_FOUND_ERR: number; + static readonly NOT_SUPPORTED_ERR: number; + static readonly INUSE_ATTRIBUTE_ERR: number; + static readonly INVALID_STATE_ERR: number; + static readonly SYNTAX_ERR: number; + static readonly INVALID_MODIFICATION_ERR: number; + static readonly NAMESPACE_ERR: number; + static readonly INVALID_ACCESS_ERR: number; + static readonly VALIDATION_ERR: number; + static readonly TYPE_MISMATCH_ERR: number; + static readonly SECURITY_ERR: number; + static readonly NETWORK_ERR: number; + static readonly ABORT_ERR: number; + static readonly URL_MISMATCH_ERR: number; + static readonly QUOTA_EXCEEDED_ERR: number; + static readonly TIMEOUT_ERR: number; + static readonly INVALID_NODE_TYPE_ERR: number; + static readonly DATA_CLONE_ERR: number; + get stack(): any; + set stack(value: any); +} +type WorkerGlobalScopeEventMap = { + fetch: FetchEvent; + scheduled: ScheduledEvent; + queue: QueueEvent; + unhandledrejection: PromiseRejectionEvent; + rejectionhandled: PromiseRejectionEvent; +}; +declare abstract class WorkerGlobalScope extends EventTarget { + EventTarget: typeof EventTarget; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console) */ +interface Console { + "assert"(condition?: boolean, ...data: any[]): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/clear_static) */ + clear(): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/count_static) */ + count(label?: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/countReset_static) */ + countReset(label?: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug_static) */ + debug(...data: any[]): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dir_static) */ + dir(item?: any, options?: any): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dirxml_static) */ + dirxml(...data: any[]): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static) */ + error(...data: any[]): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/group_static) */ + group(...data: any[]): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupCollapsed_static) */ + groupCollapsed(...data: any[]): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupEnd_static) */ + groupEnd(): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info_static) */ + info(...data: any[]): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static) */ + log(...data: any[]): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/table_static) */ + table(tabularData?: any, properties?: string[]): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time_static) */ + time(label?: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd_static) */ + timeEnd(label?: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeLog_static) */ + timeLog(label?: string, ...data: any[]): void; + timeStamp(label?: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace_static) */ + trace(...data: any[]): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/warn_static) */ + warn(...data: any[]): void; +} +declare const console: Console; +type BufferSource = ArrayBufferView | ArrayBuffer; +type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array; +declare namespace WebAssembly { + class CompileError extends Error { + constructor(message?: string); + } + class RuntimeError extends Error { + constructor(message?: string); + } + type ValueType = "anyfunc" | "externref" | "f32" | "f64" | "i32" | "i64" | "v128"; + interface GlobalDescriptor { + value: ValueType; + mutable?: boolean; + } + class Global { + constructor(descriptor: GlobalDescriptor, value?: any); + value: any; + valueOf(): any; + } + type ImportValue = ExportValue | number; + type ModuleImports = Record; + type Imports = Record; + type ExportValue = Function | Global | Memory | Table; + type Exports = Record; + class Instance { + constructor(module: Module, imports?: Imports); + readonly exports: Exports; + } + interface MemoryDescriptor { + initial: number; + maximum?: number; + shared?: boolean; + } + class Memory { + constructor(descriptor: MemoryDescriptor); + readonly buffer: ArrayBuffer; + grow(delta: number): number; + } + type ImportExportKind = "function" | "global" | "memory" | "table"; + interface ModuleExportDescriptor { + kind: ImportExportKind; + name: string; + } + interface ModuleImportDescriptor { + kind: ImportExportKind; + module: string; + name: string; + } + abstract class Module { + static customSections(module: Module, sectionName: string): ArrayBuffer[]; + static exports(module: Module): ModuleExportDescriptor[]; + static imports(module: Module): ModuleImportDescriptor[]; + } + type TableKind = "anyfunc" | "externref"; + interface TableDescriptor { + element: TableKind; + initial: number; + maximum?: number; + } + class Table { + constructor(descriptor: TableDescriptor, value?: any); + readonly length: number; + get(index: number): any; + grow(delta: number, value?: any): number; + set(index: number, value?: any): void; + } + function instantiate(module: Module, imports?: Imports): Promise; + function validate(bytes: BufferSource): boolean; +} +/** + * This ServiceWorker API interface represents the global execution context of a service worker. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope) + */ +interface ServiceWorkerGlobalScope extends WorkerGlobalScope { + DOMException: typeof DOMException; + WorkerGlobalScope: typeof WorkerGlobalScope; + btoa(data: string): string; + atob(data: string): string; + setTimeout(callback: (...args: any[]) => void, msDelay?: number): number; + setTimeout(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number; + clearTimeout(timeoutId: number | null): void; + setInterval(callback: (...args: any[]) => void, msDelay?: number): number; + setInterval(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number; + clearInterval(timeoutId: number | null): void; + queueMicrotask(task: Function): void; + structuredClone(value: T, options?: StructuredSerializeOptions): T; + reportError(error: any): void; + fetch(input: RequestInfo | URL, init?: RequestInit): Promise; + self: ServiceWorkerGlobalScope; + crypto: Crypto; + caches: CacheStorage; + scheduler: Scheduler; + performance: Performance; + Cloudflare: Cloudflare; + readonly origin: string; + Event: typeof Event; + ExtendableEvent: typeof ExtendableEvent; + CustomEvent: typeof CustomEvent; + PromiseRejectionEvent: typeof PromiseRejectionEvent; + FetchEvent: typeof FetchEvent; + TailEvent: typeof TailEvent; + TraceEvent: typeof TailEvent; + ScheduledEvent: typeof ScheduledEvent; + MessageEvent: typeof MessageEvent; + CloseEvent: typeof CloseEvent; + ReadableStreamDefaultReader: typeof ReadableStreamDefaultReader; + ReadableStreamBYOBReader: typeof ReadableStreamBYOBReader; + ReadableStream: typeof ReadableStream; + WritableStream: typeof WritableStream; + WritableStreamDefaultWriter: typeof WritableStreamDefaultWriter; + TransformStream: typeof TransformStream; + ByteLengthQueuingStrategy: typeof ByteLengthQueuingStrategy; + CountQueuingStrategy: typeof CountQueuingStrategy; + ErrorEvent: typeof ErrorEvent; + EventSource: typeof EventSource; + ReadableStreamBYOBRequest: typeof ReadableStreamBYOBRequest; + ReadableStreamDefaultController: typeof ReadableStreamDefaultController; + ReadableByteStreamController: typeof ReadableByteStreamController; + WritableStreamDefaultController: typeof WritableStreamDefaultController; + TransformStreamDefaultController: typeof TransformStreamDefaultController; + CompressionStream: typeof CompressionStream; + DecompressionStream: typeof DecompressionStream; + TextEncoderStream: typeof TextEncoderStream; + TextDecoderStream: typeof TextDecoderStream; + Headers: typeof Headers; + Body: typeof Body; + Request: typeof Request; + Response: typeof Response; + WebSocket: typeof WebSocket; + WebSocketPair: typeof WebSocketPair; + WebSocketRequestResponsePair: typeof WebSocketRequestResponsePair; + AbortController: typeof AbortController; + AbortSignal: typeof AbortSignal; + TextDecoder: typeof TextDecoder; + TextEncoder: typeof TextEncoder; + navigator: Navigator; + Navigator: typeof Navigator; + URL: typeof URL; + URLSearchParams: typeof URLSearchParams; + URLPattern: typeof URLPattern; + Blob: typeof Blob; + File: typeof File; + FormData: typeof FormData; + Crypto: typeof Crypto; + SubtleCrypto: typeof SubtleCrypto; + CryptoKey: typeof CryptoKey; + CacheStorage: typeof CacheStorage; + Cache: typeof Cache; + FixedLengthStream: typeof FixedLengthStream; + IdentityTransformStream: typeof IdentityTransformStream; + HTMLRewriter: typeof HTMLRewriter; +} +declare function addEventListener(type: Type, handler: EventListenerOrEventListenerObject, options?: EventTargetAddEventListenerOptions | boolean): void; +declare function removeEventListener(type: Type, handler: EventListenerOrEventListenerObject, options?: EventTargetEventListenerOptions | boolean): void; +/** + * Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/dispatchEvent) + */ +declare function dispatchEvent(event: WorkerGlobalScopeEventMap[keyof WorkerGlobalScopeEventMap]): boolean; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/btoa) */ +declare function btoa(data: string): string; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/atob) */ +declare function atob(data: string): string; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setTimeout) */ +declare function setTimeout(callback: (...args: any[]) => void, msDelay?: number): number; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setTimeout) */ +declare function setTimeout(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/clearTimeout) */ +declare function clearTimeout(timeoutId: number | null): void; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setInterval) */ +declare function setInterval(callback: (...args: any[]) => void, msDelay?: number): number; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setInterval) */ +declare function setInterval(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/clearInterval) */ +declare function clearInterval(timeoutId: number | null): void; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/queueMicrotask) */ +declare function queueMicrotask(task: Function): void; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/structuredClone) */ +declare function structuredClone(value: T, options?: StructuredSerializeOptions): T; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/reportError) */ +declare function reportError(error: any): void; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/fetch) */ +declare function fetch(input: RequestInfo | URL, init?: RequestInit): Promise; +declare const self: ServiceWorkerGlobalScope; +/** +* The Web Crypto API provides a set of low-level functions for common cryptographic tasks. +* The Workers runtime implements the full surface of this API, but with some differences in +* the [supported algorithms](https://developers.cloudflare.com/workers/runtime-apis/web-crypto/#supported-algorithms) +* compared to those implemented in most browsers. +* +* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/web-crypto/) +*/ +declare const crypto: Crypto; +/** +* The Cache API allows fine grained control of reading and writing from the Cloudflare global network cache. +* +* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/cache/) +*/ +declare const caches: CacheStorage; +declare const scheduler: Scheduler; +/** +* The Workers runtime supports a subset of the Performance API, used to measure timing and performance, +* as well as timing of subrequests and other operations. +* +* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/performance/) +*/ +declare const performance: Performance; +declare const Cloudflare: Cloudflare; +declare const origin: string; +declare const navigator: Navigator; +interface TestController { +} +interface ExecutionContext { + waitUntil(promise: Promise): void; + passThroughOnException(): void; + props: any; +} +type ExportedHandlerFetchHandler = (request: Request>, env: Env, ctx: ExecutionContext) => Response | Promise; +type ExportedHandlerTailHandler = (events: TraceItem[], env: Env, ctx: ExecutionContext) => void | Promise; +type ExportedHandlerTraceHandler = (traces: TraceItem[], env: Env, ctx: ExecutionContext) => void | Promise; +type ExportedHandlerTailStreamHandler = (event: TailStream.TailEvent, env: Env, ctx: ExecutionContext) => TailStream.TailEventHandlerType | Promise; +type ExportedHandlerScheduledHandler = (controller: ScheduledController, env: Env, ctx: ExecutionContext) => void | Promise; +type ExportedHandlerQueueHandler = (batch: MessageBatch, env: Env, ctx: ExecutionContext) => void | Promise; +type ExportedHandlerTestHandler = (controller: TestController, env: Env, ctx: ExecutionContext) => void | Promise; +interface ExportedHandler { + fetch?: ExportedHandlerFetchHandler; + tail?: ExportedHandlerTailHandler; + trace?: ExportedHandlerTraceHandler; + tailStream?: ExportedHandlerTailStreamHandler; + scheduled?: ExportedHandlerScheduledHandler; + test?: ExportedHandlerTestHandler; + email?: EmailExportedHandler; + queue?: ExportedHandlerQueueHandler; +} +interface StructuredSerializeOptions { + transfer?: any[]; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent) */ +declare abstract class PromiseRejectionEvent extends Event { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent/promise) */ + readonly promise: Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent/reason) */ + readonly reason: any; +} +declare abstract class Navigator { + sendBeacon(url: string, body?: (ReadableStream | string | (ArrayBuffer | ArrayBufferView) | Blob | FormData | URLSearchParams | URLSearchParams)): boolean; + readonly userAgent: string; + readonly hardwareConcurrency: number; + readonly language: string; + readonly languages: string[]; +} +/** +* The Workers runtime supports a subset of the Performance API, used to measure timing and performance, +* as well as timing of subrequests and other operations. +* +* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/performance/) +*/ +interface Performance { + /* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/performance/#performancetimeorigin) */ + readonly timeOrigin: number; + /* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/performance/#performancenow) */ + now(): number; +} +interface AlarmInvocationInfo { + readonly isRetry: boolean; + readonly retryCount: number; +} +interface Cloudflare { + readonly compatibilityFlags: Record; +} +interface DurableObject { + fetch(request: Request): Response | Promise; + alarm?(alarmInfo?: AlarmInvocationInfo): void | Promise; + webSocketMessage?(ws: WebSocket, message: string | ArrayBuffer): void | Promise; + webSocketClose?(ws: WebSocket, code: number, reason: string, wasClean: boolean): void | Promise; + webSocketError?(ws: WebSocket, error: unknown): void | Promise; +} +type DurableObjectStub = Fetcher & { + readonly id: DurableObjectId; + readonly name?: string; +}; +interface DurableObjectId { + toString(): string; + equals(other: DurableObjectId): boolean; + readonly name?: string; +} +interface DurableObjectNamespace { + newUniqueId(options?: DurableObjectNamespaceNewUniqueIdOptions): DurableObjectId; + idFromName(name: string): DurableObjectId; + idFromString(id: string): DurableObjectId; + get(id: DurableObjectId, options?: DurableObjectNamespaceGetDurableObjectOptions): DurableObjectStub; + jurisdiction(jurisdiction: DurableObjectJurisdiction): DurableObjectNamespace; +} +type DurableObjectJurisdiction = "eu" | "fedramp" | "fedramp-high"; +interface DurableObjectNamespaceNewUniqueIdOptions { + jurisdiction?: DurableObjectJurisdiction; +} +type DurableObjectLocationHint = "wnam" | "enam" | "sam" | "weur" | "eeur" | "apac" | "oc" | "afr" | "me"; +interface DurableObjectNamespaceGetDurableObjectOptions { + locationHint?: DurableObjectLocationHint; +} +interface DurableObjectState { + waitUntil(promise: Promise): void; + readonly id: DurableObjectId; + readonly storage: DurableObjectStorage; + container?: Container; + blockConcurrencyWhile(callback: () => Promise): Promise; + acceptWebSocket(ws: WebSocket, tags?: string[]): void; + getWebSockets(tag?: string): WebSocket[]; + setWebSocketAutoResponse(maybeReqResp?: WebSocketRequestResponsePair): void; + getWebSocketAutoResponse(): WebSocketRequestResponsePair | null; + getWebSocketAutoResponseTimestamp(ws: WebSocket): Date | null; + setHibernatableWebSocketEventTimeout(timeoutMs?: number): void; + getHibernatableWebSocketEventTimeout(): number | null; + getTags(ws: WebSocket): string[]; + abort(reason?: string): void; +} +interface DurableObjectTransaction { + get(key: string, options?: DurableObjectGetOptions): Promise; + get(keys: string[], options?: DurableObjectGetOptions): Promise>; + list(options?: DurableObjectListOptions): Promise>; + put(key: string, value: T, options?: DurableObjectPutOptions): Promise; + put(entries: Record, options?: DurableObjectPutOptions): Promise; + delete(key: string, options?: DurableObjectPutOptions): Promise; + delete(keys: string[], options?: DurableObjectPutOptions): Promise; + rollback(): void; + getAlarm(options?: DurableObjectGetAlarmOptions): Promise; + setAlarm(scheduledTime: number | Date, options?: DurableObjectSetAlarmOptions): Promise; + deleteAlarm(options?: DurableObjectSetAlarmOptions): Promise; +} +interface DurableObjectStorage { + get(key: string, options?: DurableObjectGetOptions): Promise; + get(keys: string[], options?: DurableObjectGetOptions): Promise>; + list(options?: DurableObjectListOptions): Promise>; + put(key: string, value: T, options?: DurableObjectPutOptions): Promise; + put(entries: Record, options?: DurableObjectPutOptions): Promise; + delete(key: string, options?: DurableObjectPutOptions): Promise; + delete(keys: string[], options?: DurableObjectPutOptions): Promise; + deleteAll(options?: DurableObjectPutOptions): Promise; + transaction(closure: (txn: DurableObjectTransaction) => Promise): Promise; + getAlarm(options?: DurableObjectGetAlarmOptions): Promise; + setAlarm(scheduledTime: number | Date, options?: DurableObjectSetAlarmOptions): Promise; + deleteAlarm(options?: DurableObjectSetAlarmOptions): Promise; + sync(): Promise; + sql: SqlStorage; + transactionSync(closure: () => T): T; + getCurrentBookmark(): Promise; + getBookmarkForTime(timestamp: number | Date): Promise; + onNextSessionRestoreBookmark(bookmark: string): Promise; +} +interface DurableObjectListOptions { + start?: string; + startAfter?: string; + end?: string; + prefix?: string; + reverse?: boolean; + limit?: number; + allowConcurrency?: boolean; + noCache?: boolean; +} +interface DurableObjectGetOptions { + allowConcurrency?: boolean; + noCache?: boolean; +} +interface DurableObjectGetAlarmOptions { + allowConcurrency?: boolean; +} +interface DurableObjectPutOptions { + allowConcurrency?: boolean; + allowUnconfirmed?: boolean; + noCache?: boolean; +} +interface DurableObjectSetAlarmOptions { + allowConcurrency?: boolean; + allowUnconfirmed?: boolean; +} +declare class WebSocketRequestResponsePair { + constructor(request: string, response: string); + get request(): string; + get response(): string; +} +interface AnalyticsEngineDataset { + writeDataPoint(event?: AnalyticsEngineDataPoint): void; +} +interface AnalyticsEngineDataPoint { + indexes?: ((ArrayBuffer | string) | null)[]; + doubles?: number[]; + blobs?: ((ArrayBuffer | string) | null)[]; +} +/** + * An event which takes place in the DOM. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event) + */ +declare class Event { + constructor(type: string, init?: EventInit); + /** + * Returns the type of event, e.g. "click", "hashchange", or "submit". + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/type) + */ + get type(): string; + /** + * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/eventPhase) + */ + get eventPhase(): number; + /** + * Returns true or false depending on how event was initialized. True if event invokes listeners past a ShadowRoot node that is the root of its target, and false otherwise. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/composed) + */ + get composed(): boolean; + /** + * Returns true or false depending on how event was initialized. True if event goes through its target's ancestors in reverse tree order, and false otherwise. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/bubbles) + */ + get bubbles(): boolean; + /** + * Returns true or false depending on how event was initialized. Its return value does not always carry meaning, but true can indicate that part of the operation during which event was dispatched, can be canceled by invoking the preventDefault() method. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/cancelable) + */ + get cancelable(): boolean; + /** + * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/defaultPrevented) + */ + get defaultPrevented(): boolean; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/returnValue) + */ + get returnValue(): boolean; + /** + * Returns the object whose event listener's callback is currently being invoked. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/currentTarget) + */ + get currentTarget(): EventTarget | undefined; + /** + * Returns the object to which event is dispatched (its target). + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/target) + */ + get target(): EventTarget | undefined; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/srcElement) + */ + get srcElement(): EventTarget | undefined; + /** + * Returns the event's timestamp as the number of milliseconds measured relative to the time origin. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/timeStamp) + */ + get timeStamp(): number; + /** + * Returns true if event was dispatched by the user agent, and false otherwise. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/isTrusted) + */ + get isTrusted(): boolean; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/cancelBubble) + */ + get cancelBubble(): boolean; + /** + * @deprecated + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/cancelBubble) + */ + set cancelBubble(value: boolean); + /** + * Invoking this method prevents event from reaching any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any other objects. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/stopImmediatePropagation) + */ + stopImmediatePropagation(): void; + /** + * If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/preventDefault) + */ + preventDefault(): void; + /** + * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/stopPropagation) + */ + stopPropagation(): void; + /** + * Returns the invocation target objects of event's path (objects on which listeners will be invoked), except for any nodes in shadow trees of which the shadow root's mode is "closed" that are not reachable from event's currentTarget. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/composedPath) + */ + composedPath(): EventTarget[]; + static readonly NONE: number; + static readonly CAPTURING_PHASE: number; + static readonly AT_TARGET: number; + static readonly BUBBLING_PHASE: number; +} +interface EventInit { + bubbles?: boolean; + cancelable?: boolean; + composed?: boolean; +} +type EventListener = (event: EventType) => void; +interface EventListenerObject { + handleEvent(event: EventType): void; +} +type EventListenerOrEventListenerObject = EventListener | EventListenerObject; +/** + * EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget) + */ +declare class EventTarget = Record> { + constructor(); + /** + * Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched. + * + * The options argument sets listener-specific options. For compatibility this can be a boolean, in which case the method behaves exactly as if the value was specified as options's capture. + * + * When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET. + * + * When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in § 2.8 Observing event listeners. + * + * When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed. + * + * If an AbortSignal is passed for options's signal, then the event listener will be removed when signal is aborted. + * + * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener) + */ + addEventListener(type: Type, handler: EventListenerOrEventListenerObject, options?: EventTargetAddEventListenerOptions | boolean): void; + /** + * Removes the event listener in target's event listener list with the same type, callback, and options. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/removeEventListener) + */ + removeEventListener(type: Type, handler: EventListenerOrEventListenerObject, options?: EventTargetEventListenerOptions | boolean): void; + /** + * Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/dispatchEvent) + */ + dispatchEvent(event: EventMap[keyof EventMap]): boolean; +} +interface EventTargetEventListenerOptions { + capture?: boolean; +} +interface EventTargetAddEventListenerOptions { + capture?: boolean; + passive?: boolean; + once?: boolean; + signal?: AbortSignal; +} +interface EventTargetHandlerObject { + handleEvent: (event: Event) => any | undefined; +} +/** + * A controller object that allows you to abort one or more DOM requests as and when desired. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController) + */ +declare class AbortController { + constructor(); + /** + * Returns the AbortSignal object associated with this object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/signal) + */ + get signal(): AbortSignal; + /** + * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/abort) + */ + abort(reason?: any): void; +} +/** + * A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal) + */ +declare abstract class AbortSignal extends EventTarget { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_static) */ + static abort(reason?: any): AbortSignal; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/timeout_static) */ + static timeout(delay: number): AbortSignal; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/any_static) */ + static any(signals: AbortSignal[]): AbortSignal; + /** + * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/aborted) + */ + get aborted(): boolean; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/reason) */ + get reason(): any; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_event) */ + get onabort(): any | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_event) */ + set onabort(value: any | null); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/throwIfAborted) */ + throwIfAborted(): void; +} +interface Scheduler { + wait(delay: number, maybeOptions?: SchedulerWaitOptions): Promise; +} +interface SchedulerWaitOptions { + signal?: AbortSignal; +} +/** + * Extends the lifetime of the install and activate events dispatched on the global scope as part of the service worker lifecycle. This ensures that any functional events (like FetchEvent) are not dispatched until it upgrades database schemas and deletes the outdated cache entries. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableEvent) + */ +declare abstract class ExtendableEvent extends Event { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) */ + waitUntil(promise: Promise): void; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent) */ +declare class CustomEvent extends Event { + constructor(type: string, init?: CustomEventCustomEventInit); + /** + * Returns any custom data event was created with. Typically used for synthetic events. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent/detail) + */ + get detail(): T; +} +interface CustomEventCustomEventInit { + bubbles?: boolean; + cancelable?: boolean; + composed?: boolean; + detail?: any; +} +/** + * A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob) + */ +declare class Blob { + constructor(type?: ((ArrayBuffer | ArrayBufferView) | string | Blob)[], options?: BlobOptions); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */ + get size(): number; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */ + get type(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */ + slice(start?: number, end?: number, type?: string): Blob; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/arrayBuffer) */ + arrayBuffer(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/bytes) */ + bytes(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */ + text(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/stream) */ + stream(): ReadableStream; +} +interface BlobOptions { + type?: string; +} +/** + * Provides information about files and allows JavaScript in a web page to access their content. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/File) + */ +declare class File extends Blob { + constructor(bits: ((ArrayBuffer | ArrayBufferView) | string | Blob)[] | undefined, name: string, options?: FileOptions); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */ + get name(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */ + get lastModified(): number; +} +interface FileOptions { + type?: string; + lastModified?: number; +} +/** +* The Cache API allows fine grained control of reading and writing from the Cloudflare global network cache. +* +* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/cache/) +*/ +declare abstract class CacheStorage { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/open) */ + open(cacheName: string): Promise; + readonly default: Cache; +} +/** +* The Cache API allows fine grained control of reading and writing from the Cloudflare global network cache. +* +* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/cache/) +*/ +declare abstract class Cache { + /* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/cache/#delete) */ + delete(request: RequestInfo | URL, options?: CacheQueryOptions): Promise; + /* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/cache/#match) */ + match(request: RequestInfo | URL, options?: CacheQueryOptions): Promise; + /* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/cache/#put) */ + put(request: RequestInfo | URL, response: Response): Promise; +} +interface CacheQueryOptions { + ignoreMethod?: boolean; +} +/** +* The Web Crypto API provides a set of low-level functions for common cryptographic tasks. +* The Workers runtime implements the full surface of this API, but with some differences in +* the [supported algorithms](https://developers.cloudflare.com/workers/runtime-apis/web-crypto/#supported-algorithms) +* compared to those implemented in most browsers. +* +* [Cloudflare Docs Reference](https://developers.cloudflare.com/workers/runtime-apis/web-crypto/) +*/ +declare abstract class Crypto { + /** + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/subtle) + */ + get subtle(): SubtleCrypto; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/getRandomValues) */ + getRandomValues(buffer: T): T; + /** + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/randomUUID) + */ + randomUUID(): string; + DigestStream: typeof DigestStream; +} +/** + * This Web Crypto API interface provides a number of low-level cryptographic functions. It is accessed via the Crypto.subtle properties available in a window context (via Window.crypto). + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto) + */ +declare abstract class SubtleCrypto { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/encrypt) */ + encrypt(algorithm: string | SubtleCryptoEncryptAlgorithm, key: CryptoKey, plainText: ArrayBuffer | ArrayBufferView): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/decrypt) */ + decrypt(algorithm: string | SubtleCryptoEncryptAlgorithm, key: CryptoKey, cipherText: ArrayBuffer | ArrayBufferView): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/sign) */ + sign(algorithm: string | SubtleCryptoSignAlgorithm, key: CryptoKey, data: ArrayBuffer | ArrayBufferView): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/verify) */ + verify(algorithm: string | SubtleCryptoSignAlgorithm, key: CryptoKey, signature: ArrayBuffer | ArrayBufferView, data: ArrayBuffer | ArrayBufferView): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/digest) */ + digest(algorithm: string | SubtleCryptoHashAlgorithm, data: ArrayBuffer | ArrayBufferView): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/generateKey) */ + generateKey(algorithm: string | SubtleCryptoGenerateKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveKey) */ + deriveKey(algorithm: string | SubtleCryptoDeriveKeyAlgorithm, baseKey: CryptoKey, derivedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveBits) */ + deriveBits(algorithm: string | SubtleCryptoDeriveKeyAlgorithm, baseKey: CryptoKey, length?: number | null): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/importKey) */ + importKey(format: string, keyData: (ArrayBuffer | ArrayBufferView) | JsonWebKey, algorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/exportKey) */ + exportKey(format: string, key: CryptoKey): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/wrapKey) */ + wrapKey(format: string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: string | SubtleCryptoEncryptAlgorithm): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/unwrapKey) */ + unwrapKey(format: string, wrappedKey: ArrayBuffer | ArrayBufferView, unwrappingKey: CryptoKey, unwrapAlgorithm: string | SubtleCryptoEncryptAlgorithm, unwrappedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise; + timingSafeEqual(a: ArrayBuffer | ArrayBufferView, b: ArrayBuffer | ArrayBufferView): boolean; +} +/** + * The CryptoKey dictionary of the Web Crypto API represents a cryptographic key. + * Available only in secure contexts. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey) + */ +declare abstract class CryptoKey { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/type) */ + readonly type: string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/extractable) */ + readonly extractable: boolean; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/algorithm) */ + readonly algorithm: CryptoKeyKeyAlgorithm | CryptoKeyAesKeyAlgorithm | CryptoKeyHmacKeyAlgorithm | CryptoKeyRsaKeyAlgorithm | CryptoKeyEllipticKeyAlgorithm | CryptoKeyArbitraryKeyAlgorithm; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/usages) */ + readonly usages: string[]; +} +interface CryptoKeyPair { + publicKey: CryptoKey; + privateKey: CryptoKey; +} +interface JsonWebKey { + kty: string; + use?: string; + key_ops?: string[]; + alg?: string; + ext?: boolean; + crv?: string; + x?: string; + y?: string; + d?: string; + n?: string; + e?: string; + p?: string; + q?: string; + dp?: string; + dq?: string; + qi?: string; + oth?: RsaOtherPrimesInfo[]; + k?: string; +} +interface RsaOtherPrimesInfo { + r?: string; + d?: string; + t?: string; +} +interface SubtleCryptoDeriveKeyAlgorithm { + name: string; + salt?: (ArrayBuffer | ArrayBufferView); + iterations?: number; + hash?: (string | SubtleCryptoHashAlgorithm); + $public?: CryptoKey; + info?: (ArrayBuffer | ArrayBufferView); +} +interface SubtleCryptoEncryptAlgorithm { + name: string; + iv?: (ArrayBuffer | ArrayBufferView); + additionalData?: (ArrayBuffer | ArrayBufferView); + tagLength?: number; + counter?: (ArrayBuffer | ArrayBufferView); + length?: number; + label?: (ArrayBuffer | ArrayBufferView); +} +interface SubtleCryptoGenerateKeyAlgorithm { + name: string; + hash?: (string | SubtleCryptoHashAlgorithm); + modulusLength?: number; + publicExponent?: (ArrayBuffer | ArrayBufferView); + length?: number; + namedCurve?: string; +} +interface SubtleCryptoHashAlgorithm { + name: string; +} +interface SubtleCryptoImportKeyAlgorithm { + name: string; + hash?: (string | SubtleCryptoHashAlgorithm); + length?: number; + namedCurve?: string; + compressed?: boolean; +} +interface SubtleCryptoSignAlgorithm { + name: string; + hash?: (string | SubtleCryptoHashAlgorithm); + dataLength?: number; + saltLength?: number; +} +interface CryptoKeyKeyAlgorithm { + name: string; +} +interface CryptoKeyAesKeyAlgorithm { + name: string; + length: number; +} +interface CryptoKeyHmacKeyAlgorithm { + name: string; + hash: CryptoKeyKeyAlgorithm; + length: number; +} +interface CryptoKeyRsaKeyAlgorithm { + name: string; + modulusLength: number; + publicExponent: ArrayBuffer | ArrayBufferView; + hash?: CryptoKeyKeyAlgorithm; +} +interface CryptoKeyEllipticKeyAlgorithm { + name: string; + namedCurve: string; +} +interface CryptoKeyArbitraryKeyAlgorithm { + name: string; + hash?: CryptoKeyKeyAlgorithm; + namedCurve?: string; + length?: number; +} +declare class DigestStream extends WritableStream { + constructor(algorithm: string | SubtleCryptoHashAlgorithm); + readonly digest: Promise; + get bytesWritten(): number | bigint; +} +/** + * A decoder for a specific method, that is a specific character encoding, like utf-8, iso-8859-2, koi8, cp1261, gbk, etc. A decoder takes a stream of bytes as input and emits a stream of code points. For a more scalable, non-native library, see StringView – a C-like representation of strings based on typed arrays. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoder) + */ +declare class TextDecoder { + constructor(label?: string, options?: TextDecoderConstructorOptions); + /** + * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments. + * + * ``` + * var string = "", decoder = new TextDecoder(encoding), buffer; + * while(buffer = next_chunk()) { + * string += decoder.decode(buffer, {stream:true}); + * } + * string += decoder.decode(); // end-of-queue + * ``` + * + * If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoder/decode) + */ + decode(input?: (ArrayBuffer | ArrayBufferView), options?: TextDecoderDecodeOptions): string; + get encoding(): string; + get fatal(): boolean; + get ignoreBOM(): boolean; +} +/** + * TextEncoder takes a stream of code points as input and emits a stream of bytes. For a more scalable, non-native library, see StringView – a C-like representation of strings based on typed arrays. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoder) + */ +declare class TextEncoder { + constructor(); + /** + * Returns the result of running UTF-8's encoder. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoder/encode) + */ + encode(input?: string): Uint8Array; + /** + * Runs the UTF-8 encoder on source, stores the result of that operation into destination, and returns the progress made as an object wherein read is the number of converted code units of source and written is the number of bytes modified in destination. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoder/encodeInto) + */ + encodeInto(input: string, buffer: ArrayBuffer | ArrayBufferView): TextEncoderEncodeIntoResult; + get encoding(): string; +} +interface TextDecoderConstructorOptions { + fatal: boolean; + ignoreBOM: boolean; +} +interface TextDecoderDecodeOptions { + stream: boolean; +} +interface TextEncoderEncodeIntoResult { + read: number; + written: number; +} +/** + * Events providing information related to errors in scripts or in files. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent) + */ +declare class ErrorEvent extends Event { + constructor(type: string, init?: ErrorEventErrorEventInit); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/filename) */ + get filename(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/message) */ + get message(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/lineno) */ + get lineno(): number; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/colno) */ + get colno(): number; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/error) */ + get error(): any; +} +interface ErrorEventErrorEventInit { + message?: string; + filename?: string; + lineno?: number; + colno?: number; + error?: any; +} +/** + * Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using the XMLHttpRequest.send() method. It uses the same format a form would use if the encoding type were set to "multipart/form-data". + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData) + */ +declare class FormData { + constructor(); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/append) */ + append(name: string, value: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/append) */ + append(name: string, value: Blob, filename?: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/delete) */ + delete(name: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/get) */ + get(name: string): (File | string) | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/getAll) */ + getAll(name: string): (File | string)[]; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/has) */ + has(name: string): boolean; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/set) */ + set(name: string, value: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FormData/set) */ + set(name: string, value: Blob, filename?: string): void; + /* Returns an array of key, value pairs for every entry in the list. */ + entries(): IterableIterator<[ + key: string, + value: File | string + ]>; + /* Returns a list of keys in the list. */ + keys(): IterableIterator; + /* Returns a list of values in the list. */ + values(): IterableIterator<(File | string)>; + forEach(callback: (this: This, value: File | string, key: string, parent: FormData) => void, thisArg?: This): void; + [Symbol.iterator](): IterableIterator<[ + key: string, + value: File | string + ]>; +} +interface ContentOptions { + html?: boolean; +} +declare class HTMLRewriter { + constructor(); + on(selector: string, handlers: HTMLRewriterElementContentHandlers): HTMLRewriter; + onDocument(handlers: HTMLRewriterDocumentContentHandlers): HTMLRewriter; + transform(response: Response): Response; +} +interface HTMLRewriterElementContentHandlers { + element?(element: Element): void | Promise; + comments?(comment: Comment): void | Promise; + text?(element: Text): void | Promise; +} +interface HTMLRewriterDocumentContentHandlers { + doctype?(doctype: Doctype): void | Promise; + comments?(comment: Comment): void | Promise; + text?(text: Text): void | Promise; + end?(end: DocumentEnd): void | Promise; +} +interface Doctype { + readonly name: string | null; + readonly publicId: string | null; + readonly systemId: string | null; +} +interface Element { + tagName: string; + readonly attributes: IterableIterator; + readonly removed: boolean; + readonly namespaceURI: string; + getAttribute(name: string): string | null; + hasAttribute(name: string): boolean; + setAttribute(name: string, value: string): Element; + removeAttribute(name: string): Element; + before(content: string | ReadableStream | Response, options?: ContentOptions): Element; + after(content: string | ReadableStream | Response, options?: ContentOptions): Element; + prepend(content: string | ReadableStream | Response, options?: ContentOptions): Element; + append(content: string | ReadableStream | Response, options?: ContentOptions): Element; + replace(content: string | ReadableStream | Response, options?: ContentOptions): Element; + remove(): Element; + removeAndKeepContent(): Element; + setInnerContent(content: string | ReadableStream | Response, options?: ContentOptions): Element; + onEndTag(handler: (tag: EndTag) => void | Promise): void; +} +interface EndTag { + name: string; + before(content: string | ReadableStream | Response, options?: ContentOptions): EndTag; + after(content: string | ReadableStream | Response, options?: ContentOptions): EndTag; + remove(): EndTag; +} +interface Comment { + text: string; + readonly removed: boolean; + before(content: string, options?: ContentOptions): Comment; + after(content: string, options?: ContentOptions): Comment; + replace(content: string, options?: ContentOptions): Comment; + remove(): Comment; +} +interface Text { + readonly text: string; + readonly lastInTextNode: boolean; + readonly removed: boolean; + before(content: string | ReadableStream | Response, options?: ContentOptions): Text; + after(content: string | ReadableStream | Response, options?: ContentOptions): Text; + replace(content: string | ReadableStream | Response, options?: ContentOptions): Text; + remove(): Text; +} +interface DocumentEnd { + append(content: string, options?: ContentOptions): DocumentEnd; +} +/** + * This is the event type for fetch events dispatched on the service worker global scope. It contains information about the fetch, including the request and how the receiver will treat the response. It provides the event.respondWith() method, which allows us to provide a response to this fetch. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent) + */ +declare abstract class FetchEvent extends ExtendableEvent { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/request) */ + readonly request: Request; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/respondWith) */ + respondWith(promise: Response | Promise): void; + passThroughOnException(): void; +} +type HeadersInit = Headers | Iterable> | Record; +/** + * This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers) + */ +declare class Headers { + constructor(init?: HeadersInit); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/get) */ + get(name: string): string | null; + getAll(name: string): string[]; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/getSetCookie) */ + getSetCookie(): string[]; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/has) */ + has(name: string): boolean; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/set) */ + set(name: string, value: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/append) */ + append(name: string, value: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Headers/delete) */ + delete(name: string): void; + forEach(callback: (this: This, value: string, key: string, parent: Headers) => void, thisArg?: This): void; + /* Returns an iterator allowing to go through all key/value pairs contained in this object. */ + entries(): IterableIterator<[ + key: string, + value: string + ]>; + /* Returns an iterator allowing to go through all keys of the key/value pairs contained in this object. */ + keys(): IterableIterator; + /* Returns an iterator allowing to go through all values of the key/value pairs contained in this object. */ + values(): IterableIterator; + [Symbol.iterator](): IterableIterator<[ + key: string, + value: string + ]>; +} +type BodyInit = ReadableStream | string | ArrayBuffer | ArrayBufferView | Blob | URLSearchParams | FormData; +declare abstract class Body { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/body) */ + get body(): ReadableStream | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bodyUsed) */ + get bodyUsed(): boolean; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/arrayBuffer) */ + arrayBuffer(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bytes) */ + bytes(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/text) */ + text(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/json) */ + json(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/formData) */ + formData(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/blob) */ + blob(): Promise; +} +/** + * This Fetch API interface represents the response to a request. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response) + */ +declare var Response: { + prototype: Response; + new (body?: BodyInit | null, init?: ResponseInit): Response; + error(): Response; + redirect(url: string, status?: number): Response; + json(any: any, maybeInit?: (ResponseInit | Response)): Response; +}; +/** + * This Fetch API interface represents the response to a request. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response) + */ +interface Response extends Body { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/clone) */ + clone(): Response; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/status) */ + status: number; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/statusText) */ + statusText: string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/headers) */ + headers: Headers; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/ok) */ + ok: boolean; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/redirected) */ + redirected: boolean; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/url) */ + url: string; + webSocket: WebSocket | null; + cf: any | undefined; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/type) */ + type: "default" | "error"; +} +interface ResponseInit { + status?: number; + statusText?: string; + headers?: HeadersInit; + cf?: any; + webSocket?: (WebSocket | null); + encodeBody?: "automatic" | "manual"; +} +type RequestInfo> = Request | string; +/** + * This Fetch API interface represents a resource request. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request) + */ +declare var Request: { + prototype: Request; + new >(input: RequestInfo | URL, init?: RequestInit): Request; +}; +/** + * This Fetch API interface represents a resource request. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request) + */ +interface Request> extends Body { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/clone) */ + clone(): Request; + /** + * Returns request's HTTP method, which is "GET" by default. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/method) + */ + method: string; + /** + * Returns the URL of request as a string. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/url) + */ + url: string; + /** + * Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/headers) + */ + headers: Headers; + /** + * Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/redirect) + */ + redirect: string; + fetcher: Fetcher | null; + /** + * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/signal) + */ + signal: AbortSignal; + cf: Cf | undefined; + /** + * Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI] + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/integrity) + */ + integrity: string; + /** + * Returns a boolean indicating whether or not request can outlive the global in which it was created. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/keepalive) + */ + keepalive: boolean; + /** + * Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/cache) + */ + cache?: "no-store"; +} +interface RequestInit { + /* A string to set request's method. */ + method?: string; + /* A Headers object, an object literal, or an array of two-item arrays to set request's headers. */ + headers?: HeadersInit; + /* A BodyInit object or null to set request's body. */ + body?: BodyInit | null; + /* A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect. */ + redirect?: string; + fetcher?: (Fetcher | null); + cf?: Cf; + /* A string indicating how the request will interact with the browser's cache to set request's cache. */ + cache?: "no-store"; + /* A cryptographic hash of the resource to be fetched by request. Sets request's integrity. */ + integrity?: string; + /* An AbortSignal to set request's signal. */ + signal?: (AbortSignal | null); + encodeResponseBody?: "automatic" | "manual"; +} +type Service = Fetcher; +type Fetcher = (T extends Rpc.EntrypointBranded ? Rpc.Provider : unknown) & { + fetch(input: RequestInfo | URL, init?: RequestInit): Promise; + connect(address: SocketAddress | string, options?: SocketOptions): Socket; +}; +interface KVNamespaceListKey { + name: Key; + expiration?: number; + metadata?: Metadata; +} +type KVNamespaceListResult = { + list_complete: false; + keys: KVNamespaceListKey[]; + cursor: string; + cacheStatus: string | null; +} | { + list_complete: true; + keys: KVNamespaceListKey[]; + cacheStatus: string | null; +}; +interface KVNamespace { + get(key: Key, options?: Partial>): Promise; + get(key: Key, type: "text"): Promise; + get(key: Key, type: "json"): Promise; + get(key: Key, type: "arrayBuffer"): Promise; + get(key: Key, type: "stream"): Promise; + get(key: Key, options?: KVNamespaceGetOptions<"text">): Promise; + get(key: Key, options?: KVNamespaceGetOptions<"json">): Promise; + get(key: Key, options?: KVNamespaceGetOptions<"arrayBuffer">): Promise; + get(key: Key, options?: KVNamespaceGetOptions<"stream">): Promise; + get(key: Array, type: "text"): Promise>; + get(key: Array, type: "json"): Promise>; + get(key: Array, options?: Partial>): Promise>; + get(key: Array, options?: KVNamespaceGetOptions<"text">): Promise>; + get(key: Array, options?: KVNamespaceGetOptions<"json">): Promise>; + list(options?: KVNamespaceListOptions): Promise>; + put(key: Key, value: string | ArrayBuffer | ArrayBufferView | ReadableStream, options?: KVNamespacePutOptions): Promise; + getWithMetadata(key: Key, options?: Partial>): Promise>; + getWithMetadata(key: Key, type: "text"): Promise>; + getWithMetadata(key: Key, type: "json"): Promise>; + getWithMetadata(key: Key, type: "arrayBuffer"): Promise>; + getWithMetadata(key: Key, type: "stream"): Promise>; + getWithMetadata(key: Key, options: KVNamespaceGetOptions<"text">): Promise>; + getWithMetadata(key: Key, options: KVNamespaceGetOptions<"json">): Promise>; + getWithMetadata(key: Key, options: KVNamespaceGetOptions<"arrayBuffer">): Promise>; + getWithMetadata(key: Key, options: KVNamespaceGetOptions<"stream">): Promise>; + getWithMetadata(key: Array, type: "text"): Promise>>; + getWithMetadata(key: Array, type: "json"): Promise>>; + getWithMetadata(key: Array, options?: Partial>): Promise>>; + getWithMetadata(key: Array, options?: KVNamespaceGetOptions<"text">): Promise>>; + getWithMetadata(key: Array, options?: KVNamespaceGetOptions<"json">): Promise>>; + delete(key: Key): Promise; +} +interface KVNamespaceListOptions { + limit?: number; + prefix?: (string | null); + cursor?: (string | null); +} +interface KVNamespaceGetOptions { + type: Type; + cacheTtl?: number; +} +interface KVNamespacePutOptions { + expiration?: number; + expirationTtl?: number; + metadata?: (any | null); +} +interface KVNamespaceGetWithMetadataResult { + value: Value | null; + metadata: Metadata | null; + cacheStatus: string | null; +} +type QueueContentType = "text" | "bytes" | "json" | "v8"; +interface Queue { + send(message: Body, options?: QueueSendOptions): Promise; + sendBatch(messages: Iterable>, options?: QueueSendBatchOptions): Promise; +} +interface QueueSendOptions { + contentType?: QueueContentType; + delaySeconds?: number; +} +interface QueueSendBatchOptions { + delaySeconds?: number; +} +interface MessageSendRequest { + body: Body; + contentType?: QueueContentType; + delaySeconds?: number; +} +interface QueueRetryOptions { + delaySeconds?: number; +} +interface Message { + readonly id: string; + readonly timestamp: Date; + readonly body: Body; + readonly attempts: number; + retry(options?: QueueRetryOptions): void; + ack(): void; +} +interface QueueEvent extends ExtendableEvent { + readonly messages: readonly Message[]; + readonly queue: string; + retryAll(options?: QueueRetryOptions): void; + ackAll(): void; +} +interface MessageBatch { + readonly messages: readonly Message[]; + readonly queue: string; + retryAll(options?: QueueRetryOptions): void; + ackAll(): void; +} +interface R2Error extends Error { + readonly name: string; + readonly code: number; + readonly message: string; + readonly action: string; + readonly stack: any; +} +interface R2ListOptions { + limit?: number; + prefix?: string; + cursor?: string; + delimiter?: string; + startAfter?: string; + include?: ("httpMetadata" | "customMetadata")[]; +} +declare abstract class R2Bucket { + head(key: string): Promise; + get(key: string, options: R2GetOptions & { + onlyIf: R2Conditional | Headers; + }): Promise; + get(key: string, options?: R2GetOptions): Promise; + put(key: string, value: ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob, options?: R2PutOptions & { + onlyIf: R2Conditional | Headers; + }): Promise; + put(key: string, value: ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob, options?: R2PutOptions): Promise; + createMultipartUpload(key: string, options?: R2MultipartOptions): Promise; + resumeMultipartUpload(key: string, uploadId: string): R2MultipartUpload; + delete(keys: string | string[]): Promise; + list(options?: R2ListOptions): Promise; +} +interface R2MultipartUpload { + readonly key: string; + readonly uploadId: string; + uploadPart(partNumber: number, value: ReadableStream | (ArrayBuffer | ArrayBufferView) | string | Blob, options?: R2UploadPartOptions): Promise; + abort(): Promise; + complete(uploadedParts: R2UploadedPart[]): Promise; +} +interface R2UploadedPart { + partNumber: number; + etag: string; +} +declare abstract class R2Object { + readonly key: string; + readonly version: string; + readonly size: number; + readonly etag: string; + readonly httpEtag: string; + readonly checksums: R2Checksums; + readonly uploaded: Date; + readonly httpMetadata?: R2HTTPMetadata; + readonly customMetadata?: Record; + readonly range?: R2Range; + readonly storageClass: string; + readonly ssecKeyMd5?: string; + writeHttpMetadata(headers: Headers): void; +} +interface R2ObjectBody extends R2Object { + get body(): ReadableStream; + get bodyUsed(): boolean; + arrayBuffer(): Promise; + bytes(): Promise; + text(): Promise; + json(): Promise; + blob(): Promise; +} +type R2Range = { + offset: number; + length?: number; +} | { + offset?: number; + length: number; +} | { + suffix: number; +}; +interface R2Conditional { + etagMatches?: string; + etagDoesNotMatch?: string; + uploadedBefore?: Date; + uploadedAfter?: Date; + secondsGranularity?: boolean; +} +interface R2GetOptions { + onlyIf?: (R2Conditional | Headers); + range?: (R2Range | Headers); + ssecKey?: (ArrayBuffer | string); +} +interface R2PutOptions { + onlyIf?: (R2Conditional | Headers); + httpMetadata?: (R2HTTPMetadata | Headers); + customMetadata?: Record; + md5?: ((ArrayBuffer | ArrayBufferView) | string); + sha1?: ((ArrayBuffer | ArrayBufferView) | string); + sha256?: ((ArrayBuffer | ArrayBufferView) | string); + sha384?: ((ArrayBuffer | ArrayBufferView) | string); + sha512?: ((ArrayBuffer | ArrayBufferView) | string); + storageClass?: string; + ssecKey?: (ArrayBuffer | string); +} +interface R2MultipartOptions { + httpMetadata?: (R2HTTPMetadata | Headers); + customMetadata?: Record; + storageClass?: string; + ssecKey?: (ArrayBuffer | string); +} +interface R2Checksums { + readonly md5?: ArrayBuffer; + readonly sha1?: ArrayBuffer; + readonly sha256?: ArrayBuffer; + readonly sha384?: ArrayBuffer; + readonly sha512?: ArrayBuffer; + toJSON(): R2StringChecksums; +} +interface R2StringChecksums { + md5?: string; + sha1?: string; + sha256?: string; + sha384?: string; + sha512?: string; +} +interface R2HTTPMetadata { + contentType?: string; + contentLanguage?: string; + contentDisposition?: string; + contentEncoding?: string; + cacheControl?: string; + cacheExpiry?: Date; +} +type R2Objects = { + objects: R2Object[]; + delimitedPrefixes: string[]; +} & ({ + truncated: true; + cursor: string; +} | { + truncated: false; +}); +interface R2UploadPartOptions { + ssecKey?: (ArrayBuffer | string); +} +declare abstract class ScheduledEvent extends ExtendableEvent { + readonly scheduledTime: number; + readonly cron: string; + noRetry(): void; +} +interface ScheduledController { + readonly scheduledTime: number; + readonly cron: string; + noRetry(): void; +} +interface QueuingStrategy { + highWaterMark?: (number | bigint); + size?: (chunk: T) => number | bigint; +} +interface UnderlyingSink { + type?: string; + start?: (controller: WritableStreamDefaultController) => void | Promise; + write?: (chunk: W, controller: WritableStreamDefaultController) => void | Promise; + abort?: (reason: any) => void | Promise; + close?: () => void | Promise; +} +interface UnderlyingByteSource { + type: "bytes"; + autoAllocateChunkSize?: number; + start?: (controller: ReadableByteStreamController) => void | Promise; + pull?: (controller: ReadableByteStreamController) => void | Promise; + cancel?: (reason: any) => void | Promise; +} +interface UnderlyingSource { + type?: "" | undefined; + start?: (controller: ReadableStreamDefaultController) => void | Promise; + pull?: (controller: ReadableStreamDefaultController) => void | Promise; + cancel?: (reason: any) => void | Promise; + expectedLength?: (number | bigint); +} +interface Transformer { + readableType?: string; + writableType?: string; + start?: (controller: TransformStreamDefaultController) => void | Promise; + transform?: (chunk: I, controller: TransformStreamDefaultController) => void | Promise; + flush?: (controller: TransformStreamDefaultController) => void | Promise; + cancel?: (reason: any) => void | Promise; + expectedLength?: number; +} +interface StreamPipeOptions { + /** + * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered. + * + * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader. + * + * Errors and closures of the source and destination streams propagate as follows: + * + * An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination. + * + * An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source. + * + * When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error. + * + * If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source. + * + * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set. + */ + preventClose?: boolean; + preventAbort?: boolean; + preventCancel?: boolean; + signal?: AbortSignal; +} +type ReadableStreamReadResult = { + done: false; + value: R; +} | { + done: true; + value?: undefined; +}; +/** + * This Streams API interface represents a readable stream of byte data. The Fetch API offers a concrete instance of a ReadableStream through the body property of a Response object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream) + */ +interface ReadableStream { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/locked) */ + get locked(): boolean; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/cancel) */ + cancel(reason?: any): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/getReader) */ + getReader(): ReadableStreamDefaultReader; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/getReader) */ + getReader(options: ReadableStreamGetReaderOptions): ReadableStreamBYOBReader; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/pipeThrough) */ + pipeThrough(transform: ReadableWritablePair, options?: StreamPipeOptions): ReadableStream; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/pipeTo) */ + pipeTo(destination: WritableStream, options?: StreamPipeOptions): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/tee) */ + tee(): [ + ReadableStream, + ReadableStream + ]; + values(options?: ReadableStreamValuesOptions): AsyncIterableIterator; + [Symbol.asyncIterator](options?: ReadableStreamValuesOptions): AsyncIterableIterator; +} +/** + * This Streams API interface represents a readable stream of byte data. The Fetch API offers a concrete instance of a ReadableStream through the body property of a Response object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream) + */ +declare const ReadableStream: { + prototype: ReadableStream; + new (underlyingSource: UnderlyingByteSource, strategy?: QueuingStrategy): ReadableStream; + new (underlyingSource?: UnderlyingSource, strategy?: QueuingStrategy): ReadableStream; +}; +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader) */ +declare class ReadableStreamDefaultReader { + constructor(stream: ReadableStream); + get closed(): Promise; + cancel(reason?: any): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader/read) */ + read(): Promise>; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader/releaseLock) */ + releaseLock(): void; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader) */ +declare class ReadableStreamBYOBReader { + constructor(stream: ReadableStream); + get closed(): Promise; + cancel(reason?: any): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/read) */ + read(view: T): Promise>; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/releaseLock) */ + releaseLock(): void; + readAtLeast(minElements: number, view: T): Promise>; +} +interface ReadableStreamBYOBReaderReadableStreamBYOBReaderReadOptions { + min?: number; +} +interface ReadableStreamGetReaderOptions { + /** + * Creates a ReadableStreamBYOBReader and locks the stream to the new reader. + * + * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation. + */ + mode: "byob"; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest) */ +declare abstract class ReadableStreamBYOBRequest { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/view) */ + get view(): Uint8Array | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respond) */ + respond(bytesWritten: number): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respondWithNewView) */ + respondWithNewView(view: ArrayBuffer | ArrayBufferView): void; + get atLeast(): number | null; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController) */ +declare abstract class ReadableStreamDefaultController { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/desiredSize) */ + get desiredSize(): number | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/close) */ + close(): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/enqueue) */ + enqueue(chunk?: R): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/error) */ + error(reason: any): void; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController) */ +declare abstract class ReadableByteStreamController { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/byobRequest) */ + get byobRequest(): ReadableStreamBYOBRequest | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/desiredSize) */ + get desiredSize(): number | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/close) */ + close(): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/enqueue) */ + enqueue(chunk: ArrayBuffer | ArrayBufferView): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/error) */ + error(reason: any): void; +} +/** + * This Streams API interface represents a controller allowing control of a WritableStream's state. When constructing a WritableStream, the underlying sink is given a corresponding WritableStreamDefaultController instance to manipulate. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController) + */ +declare abstract class WritableStreamDefaultController { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController/signal) */ + get signal(): AbortSignal; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController/error) */ + error(reason?: any): void; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController) */ +declare abstract class TransformStreamDefaultController { + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/desiredSize) */ + get desiredSize(): number | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/enqueue) */ + enqueue(chunk?: O): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/error) */ + error(reason: any): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/terminate) */ + terminate(): void; +} +interface ReadableWritablePair { + /** + * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use. + * + * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader. + */ + writable: WritableStream; + readable: ReadableStream; +} +/** + * This Streams API interface provides a standard abstraction for writing streaming data to a destination, known as a sink. This object comes with built-in backpressure and queuing. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream) + */ +declare class WritableStream { + constructor(underlyingSink?: UnderlyingSink, queuingStrategy?: QueuingStrategy); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/locked) */ + get locked(): boolean; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/abort) */ + abort(reason?: any): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/close) */ + close(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/getWriter) */ + getWriter(): WritableStreamDefaultWriter; +} +/** + * This Streams API interface is the object returned by WritableStream.getWriter() and once created locks the < writer to the WritableStream ensuring that no other streams can write to the underlying sink. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter) + */ +declare class WritableStreamDefaultWriter { + constructor(stream: WritableStream); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/closed) */ + get closed(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/ready) */ + get ready(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/desiredSize) */ + get desiredSize(): number | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/abort) */ + abort(reason?: any): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/close) */ + close(): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/write) */ + write(chunk?: W): Promise; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/releaseLock) */ + releaseLock(): void; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream) */ +declare class TransformStream { + constructor(transformer?: Transformer, writableStrategy?: QueuingStrategy, readableStrategy?: QueuingStrategy); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream/readable) */ + get readable(): ReadableStream; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream/writable) */ + get writable(): WritableStream; +} +declare class FixedLengthStream extends IdentityTransformStream { + constructor(expectedLength: number | bigint, queuingStrategy?: IdentityTransformStreamQueuingStrategy); +} +declare class IdentityTransformStream extends TransformStream { + constructor(queuingStrategy?: IdentityTransformStreamQueuingStrategy); +} +interface IdentityTransformStreamQueuingStrategy { + highWaterMark?: (number | bigint); +} +interface ReadableStreamValuesOptions { + preventCancel?: boolean; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CompressionStream) */ +declare class CompressionStream extends TransformStream { + constructor(format: "gzip" | "deflate" | "deflate-raw"); +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/DecompressionStream) */ +declare class DecompressionStream extends TransformStream { + constructor(format: "gzip" | "deflate" | "deflate-raw"); +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoderStream) */ +declare class TextEncoderStream extends TransformStream { + constructor(); + get encoding(): string; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoderStream) */ +declare class TextDecoderStream extends TransformStream { + constructor(label?: string, options?: TextDecoderStreamTextDecoderStreamInit); + get encoding(): string; + get fatal(): boolean; + get ignoreBOM(): boolean; +} +interface TextDecoderStreamTextDecoderStreamInit { + fatal?: boolean; + ignoreBOM?: boolean; +} +/** + * This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ByteLengthQueuingStrategy) + */ +declare class ByteLengthQueuingStrategy implements QueuingStrategy { + constructor(init: QueuingStrategyInit); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ByteLengthQueuingStrategy/highWaterMark) */ + get highWaterMark(): number; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/ByteLengthQueuingStrategy/size) */ + get size(): (chunk?: any) => number; +} +/** + * This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CountQueuingStrategy) + */ +declare class CountQueuingStrategy implements QueuingStrategy { + constructor(init: QueuingStrategyInit); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CountQueuingStrategy/highWaterMark) */ + get highWaterMark(): number; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/CountQueuingStrategy/size) */ + get size(): (chunk?: any) => number; +} +interface QueuingStrategyInit { + /** + * Creates a new ByteLengthQueuingStrategy with the provided high water mark. + * + * Note that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw. + */ + highWaterMark: number; +} +interface ScriptVersion { + id?: string; + tag?: string; + message?: string; +} +declare abstract class TailEvent extends ExtendableEvent { + readonly events: TraceItem[]; + readonly traces: TraceItem[]; +} +interface TraceItem { + readonly event: (TraceItemFetchEventInfo | TraceItemJsRpcEventInfo | TraceItemScheduledEventInfo | TraceItemAlarmEventInfo | TraceItemQueueEventInfo | TraceItemEmailEventInfo | TraceItemTailEventInfo | TraceItemCustomEventInfo | TraceItemHibernatableWebSocketEventInfo) | null; + readonly eventTimestamp: number | null; + readonly logs: TraceLog[]; + readonly exceptions: TraceException[]; + readonly diagnosticsChannelEvents: TraceDiagnosticChannelEvent[]; + readonly scriptName: string | null; + readonly entrypoint?: string; + readonly scriptVersion?: ScriptVersion; + readonly dispatchNamespace?: string; + readonly scriptTags?: string[]; + readonly outcome: string; + readonly executionModel: string; + readonly truncated: boolean; + readonly cpuTime: number; + readonly wallTime: number; +} +interface TraceItemAlarmEventInfo { + readonly scheduledTime: Date; +} +interface TraceItemCustomEventInfo { +} +interface TraceItemScheduledEventInfo { + readonly scheduledTime: number; + readonly cron: string; +} +interface TraceItemQueueEventInfo { + readonly queue: string; + readonly batchSize: number; +} +interface TraceItemEmailEventInfo { + readonly mailFrom: string; + readonly rcptTo: string; + readonly rawSize: number; +} +interface TraceItemTailEventInfo { + readonly consumedEvents: TraceItemTailEventInfoTailItem[]; +} +interface TraceItemTailEventInfoTailItem { + readonly scriptName: string | null; +} +interface TraceItemFetchEventInfo { + readonly response?: TraceItemFetchEventInfoResponse; + readonly request: TraceItemFetchEventInfoRequest; +} +interface TraceItemFetchEventInfoRequest { + readonly cf?: any; + readonly headers: Record; + readonly method: string; + readonly url: string; + getUnredacted(): TraceItemFetchEventInfoRequest; +} +interface TraceItemFetchEventInfoResponse { + readonly status: number; +} +interface TraceItemJsRpcEventInfo { + readonly rpcMethod: string; +} +interface TraceItemHibernatableWebSocketEventInfo { + readonly getWebSocketEvent: TraceItemHibernatableWebSocketEventInfoMessage | TraceItemHibernatableWebSocketEventInfoClose | TraceItemHibernatableWebSocketEventInfoError; +} +interface TraceItemHibernatableWebSocketEventInfoMessage { + readonly webSocketEventType: string; +} +interface TraceItemHibernatableWebSocketEventInfoClose { + readonly webSocketEventType: string; + readonly code: number; + readonly wasClean: boolean; +} +interface TraceItemHibernatableWebSocketEventInfoError { + readonly webSocketEventType: string; +} +interface TraceLog { + readonly timestamp: number; + readonly level: string; + readonly message: any; +} +interface TraceException { + readonly timestamp: number; + readonly message: string; + readonly name: string; + readonly stack?: string; +} +interface TraceDiagnosticChannelEvent { + readonly timestamp: number; + readonly channel: string; + readonly message: any; +} +interface TraceMetrics { + readonly cpuTime: number; + readonly wallTime: number; +} +interface UnsafeTraceMetrics { + fromTrace(item: TraceItem): TraceMetrics; +} +/** + * The URL interface represents an object providing static methods used for creating object URLs. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL) + */ +declare class URL { + constructor(url: string | URL, base?: string | URL); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/origin) */ + get origin(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/href) */ + get href(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/href) */ + set href(value: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/protocol) */ + get protocol(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/protocol) */ + set protocol(value: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/username) */ + get username(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/username) */ + set username(value: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/password) */ + get password(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/password) */ + set password(value: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/host) */ + get host(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/host) */ + set host(value: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/hostname) */ + get hostname(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/hostname) */ + set hostname(value: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/port) */ + get port(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/port) */ + set port(value: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/pathname) */ + get pathname(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/pathname) */ + set pathname(value: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/search) */ + get search(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/search) */ + set search(value: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/hash) */ + get hash(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/hash) */ + set hash(value: string); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/searchParams) */ + get searchParams(): URLSearchParams; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/toJSON) */ + toJSON(): string; + /*function toString() { [native code] }*/ + toString(): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/canParse_static) */ + static canParse(url: string, base?: string): boolean; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/parse_static) */ + static parse(url: string, base?: string): URL | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/createObjectURL_static) */ + static createObjectURL(object: File | Blob): string; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/revokeObjectURL_static) */ + static revokeObjectURL(object_url: string): void; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams) */ +declare class URLSearchParams { + constructor(init?: (Iterable> | Record | string)); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/size) */ + get size(): number; + /** + * Appends a specified key/value pair as a new search parameter. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/append) + */ + append(name: string, value: string): void; + /** + * Deletes the given search parameter, and its associated value, from the list of all search parameters. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/delete) + */ + delete(name: string, value?: string): void; + /** + * Returns the first value associated to the given search parameter. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/get) + */ + get(name: string): string | null; + /** + * Returns all the values association with a given search parameter. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/getAll) + */ + getAll(name: string): string[]; + /** + * Returns a Boolean indicating if such a search parameter exists. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/has) + */ + has(name: string, value?: string): boolean; + /** + * Sets the value associated to a given search parameter to the given value. If there were several values, delete the others. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/set) + */ + set(name: string, value: string): void; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/URLSearchParams/sort) */ + sort(): void; + /* Returns an array of key, value pairs for every entry in the search params. */ + entries(): IterableIterator<[ + key: string, + value: string + ]>; + /* Returns a list of keys in the search params. */ + keys(): IterableIterator; + /* Returns a list of values in the search params. */ + values(): IterableIterator; + forEach(callback: (this: This, value: string, key: string, parent: URLSearchParams) => void, thisArg?: This): void; + /*function toString() { [native code] } Returns a string containing a query string suitable for use in a URL. Does not include the question mark. */ + toString(): string; + [Symbol.iterator](): IterableIterator<[ + key: string, + value: string + ]>; +} +declare class URLPattern { + constructor(input?: (string | URLPatternInit), baseURL?: (string | URLPatternOptions), patternOptions?: URLPatternOptions); + get protocol(): string; + get username(): string; + get password(): string; + get hostname(): string; + get port(): string; + get pathname(): string; + get search(): string; + get hash(): string; + get hasRegExpGroups(): boolean; + test(input?: (string | URLPatternInit), baseURL?: string): boolean; + exec(input?: (string | URLPatternInit), baseURL?: string): URLPatternResult | null; +} +interface URLPatternInit { + protocol?: string; + username?: string; + password?: string; + hostname?: string; + port?: string; + pathname?: string; + search?: string; + hash?: string; + baseURL?: string; +} +interface URLPatternComponentResult { + input: string; + groups: Record; +} +interface URLPatternResult { + inputs: (string | URLPatternInit)[]; + protocol: URLPatternComponentResult; + username: URLPatternComponentResult; + password: URLPatternComponentResult; + hostname: URLPatternComponentResult; + port: URLPatternComponentResult; + pathname: URLPatternComponentResult; + search: URLPatternComponentResult; + hash: URLPatternComponentResult; +} +interface URLPatternOptions { + ignoreCase?: boolean; +} +/** + * A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent) + */ +declare class CloseEvent extends Event { + constructor(type: string, initializer?: CloseEventInit); + /** + * Returns the WebSocket connection close code provided by the server. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent/code) + */ + readonly code: number; + /** + * Returns the WebSocket connection close reason provided by the server. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent/reason) + */ + readonly reason: string; + /** + * Returns true if the connection closed cleanly; false otherwise. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent/wasClean) + */ + readonly wasClean: boolean; +} +interface CloseEventInit { + code?: number; + reason?: string; + wasClean?: boolean; +} +/** + * A message received by a target object. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent) + */ +declare class MessageEvent extends Event { + constructor(type: string, initializer: MessageEventInit); + /** + * Returns the data of the message. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MessageEvent/data) + */ + readonly data: ArrayBuffer | string; +} +interface MessageEventInit { + data: ArrayBuffer | string; +} +type WebSocketEventMap = { + close: CloseEvent; + message: MessageEvent; + open: Event; + error: ErrorEvent; +}; +/** + * Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket) + */ +declare var WebSocket: { + prototype: WebSocket; + new (url: string, protocols?: (string[] | string)): WebSocket; + readonly READY_STATE_CONNECTING: number; + readonly CONNECTING: number; + readonly READY_STATE_OPEN: number; + readonly OPEN: number; + readonly READY_STATE_CLOSING: number; + readonly CLOSING: number; + readonly READY_STATE_CLOSED: number; + readonly CLOSED: number; +}; +/** + * Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket) + */ +interface WebSocket extends EventTarget { + accept(): void; + /** + * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/send) + */ + send(message: (ArrayBuffer | ArrayBufferView) | string): void; + /** + * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/close) + */ + close(code?: number, reason?: string): void; + serializeAttachment(attachment: any): void; + deserializeAttachment(): any | null; + /** + * Returns the state of the WebSocket object's connection. It can have the values described below. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/readyState) + */ + readyState: number; + /** + * Returns the URL that was used to establish the WebSocket connection. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/url) + */ + url: string | null; + /** + * Returns the subprotocol selected by the server, if any. It can be used in conjunction with the array form of the constructor's second argument to perform subprotocol negotiation. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/protocol) + */ + protocol: string | null; + /** + * Returns the extensions selected by the server, if any. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/extensions) + */ + extensions: string | null; +} +declare const WebSocketPair: { + new (): { + 0: WebSocket; + 1: WebSocket; + }; +}; +interface SqlStorage { + exec>(query: string, ...bindings: any[]): SqlStorageCursor; + get databaseSize(): number; + Cursor: typeof SqlStorageCursor; + Statement: typeof SqlStorageStatement; +} +declare abstract class SqlStorageStatement { +} +type SqlStorageValue = ArrayBuffer | string | number | null; +declare abstract class SqlStorageCursor> { + next(): { + done?: false; + value: T; + } | { + done: true; + value?: never; + }; + toArray(): T[]; + one(): T; + raw(): IterableIterator; + columnNames: string[]; + get rowsRead(): number; + get rowsWritten(): number; + [Symbol.iterator](): IterableIterator; +} +interface Socket { + get readable(): ReadableStream; + get writable(): WritableStream; + get closed(): Promise; + get opened(): Promise; + get upgraded(): boolean; + get secureTransport(): "on" | "off" | "starttls"; + close(): Promise; + startTls(options?: TlsOptions): Socket; +} +interface SocketOptions { + secureTransport?: string; + allowHalfOpen: boolean; + highWaterMark?: (number | bigint); +} +interface SocketAddress { + hostname: string; + port: number; +} +interface TlsOptions { + expectedServerHostname?: string; +} +interface SocketInfo { + remoteAddress?: string; + localAddress?: string; +} +/* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource) */ +declare class EventSource extends EventTarget { + constructor(url: string, init?: EventSourceEventSourceInit); + /** + * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close) + */ + close(): void; + /** + * Returns the URL providing the event stream. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url) + */ + get url(): string; + /** + * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials) + */ + get withCredentials(): boolean; + /** + * Returns the state of this EventSource object's connection. It can have the values described below. + * + * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState) + */ + get readyState(): number; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */ + get onopen(): any | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */ + set onopen(value: any | null); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */ + get onmessage(): any | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */ + set onmessage(value: any | null); + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */ + get onerror(): any | null; + /* [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */ + set onerror(value: any | null); + static readonly CONNECTING: number; + static readonly OPEN: number; + static readonly CLOSED: number; + static from(stream: ReadableStream): EventSource; +} +interface EventSourceEventSourceInit { + withCredentials?: boolean; + fetcher?: Fetcher; +} +interface Container { + get running(): boolean; + start(options?: ContainerStartupOptions): void; + monitor(): Promise; + destroy(error?: any): Promise; + signal(signo: number): void; + getTcpPort(port: number): Fetcher; +} +interface ContainerStartupOptions { + entrypoint?: string[]; + enableInternet: boolean; + env?: Record; +} +type AiImageClassificationInput = { + image: number[]; +}; +type AiImageClassificationOutput = { + score?: number; + label?: string; +}[]; +declare abstract class BaseAiImageClassification { + inputs: AiImageClassificationInput; + postProcessedOutputs: AiImageClassificationOutput; +} +type AiImageToTextInput = { + image: number[]; + prompt?: string; + max_tokens?: number; + temperature?: number; + top_p?: number; + top_k?: number; + seed?: number; + repetition_penalty?: number; + frequency_penalty?: number; + presence_penalty?: number; + raw?: boolean; + messages?: RoleScopedChatInput[]; +}; +type AiImageToTextOutput = { + description: string; +}; +declare abstract class BaseAiImageToText { + inputs: AiImageToTextInput; + postProcessedOutputs: AiImageToTextOutput; +} +type AiImageTextToTextInput = { + image: string; + prompt?: string; + max_tokens?: number; + temperature?: number; + ignore_eos?: boolean; + top_p?: number; + top_k?: number; + seed?: number; + repetition_penalty?: number; + frequency_penalty?: number; + presence_penalty?: number; + raw?: boolean; + messages?: RoleScopedChatInput[]; +}; +type AiImageTextToTextOutput = { + description: string; +}; +declare abstract class BaseAiImageTextToText { + inputs: AiImageTextToTextInput; + postProcessedOutputs: AiImageTextToTextOutput; +} +type AiObjectDetectionInput = { + image: number[]; +}; +type AiObjectDetectionOutput = { + score?: number; + label?: string; +}[]; +declare abstract class BaseAiObjectDetection { + inputs: AiObjectDetectionInput; + postProcessedOutputs: AiObjectDetectionOutput; +} +type AiSentenceSimilarityInput = { + source: string; + sentences: string[]; +}; +type AiSentenceSimilarityOutput = number[]; +declare abstract class BaseAiSentenceSimilarity { + inputs: AiSentenceSimilarityInput; + postProcessedOutputs: AiSentenceSimilarityOutput; +} +type AiAutomaticSpeechRecognitionInput = { + audio: number[]; +}; +type AiAutomaticSpeechRecognitionOutput = { + text?: string; + words?: { + word: string; + start: number; + end: number; + }[]; + vtt?: string; +}; +declare abstract class BaseAiAutomaticSpeechRecognition { + inputs: AiAutomaticSpeechRecognitionInput; + postProcessedOutputs: AiAutomaticSpeechRecognitionOutput; +} +type AiSummarizationInput = { + input_text: string; + max_length?: number; +}; +type AiSummarizationOutput = { + summary: string; +}; +declare abstract class BaseAiSummarization { + inputs: AiSummarizationInput; + postProcessedOutputs: AiSummarizationOutput; +} +type AiTextClassificationInput = { + text: string; +}; +type AiTextClassificationOutput = { + score?: number; + label?: string; +}[]; +declare abstract class BaseAiTextClassification { + inputs: AiTextClassificationInput; + postProcessedOutputs: AiTextClassificationOutput; +} +type AiTextEmbeddingsInput = { + text: string | string[]; +}; +type AiTextEmbeddingsOutput = { + shape: number[]; + data: number[][]; +}; +declare abstract class BaseAiTextEmbeddings { + inputs: AiTextEmbeddingsInput; + postProcessedOutputs: AiTextEmbeddingsOutput; +} +type RoleScopedChatInput = { + role: "user" | "assistant" | "system" | "tool" | (string & NonNullable); + content: string; + name?: string; +}; +type AiTextGenerationToolLegacyInput = { + name: string; + description: string; + parameters?: { + type: "object" | (string & NonNullable); + properties: { + [key: string]: { + type: string; + description?: string; + }; + }; + required: string[]; + }; +}; +type AiTextGenerationToolInput = { + type: "function" | (string & NonNullable); + function: { + name: string; + description: string; + parameters?: { + type: "object" | (string & NonNullable); + properties: { + [key: string]: { + type: string; + description?: string; + }; + }; + required: string[]; + }; + }; +}; +type AiTextGenerationFunctionsInput = { + name: string; + code: string; +}; +type AiTextGenerationResponseFormat = { + type: string; + json_schema?: any; +}; +type AiTextGenerationInput = { + prompt?: string; + raw?: boolean; + stream?: boolean; + max_tokens?: number; + temperature?: number; + top_p?: number; + top_k?: number; + seed?: number; + repetition_penalty?: number; + frequency_penalty?: number; + presence_penalty?: number; + messages?: RoleScopedChatInput[]; + response_format?: AiTextGenerationResponseFormat; + tools?: AiTextGenerationToolInput[] | AiTextGenerationToolLegacyInput[] | (object & NonNullable); + functions?: AiTextGenerationFunctionsInput[]; +}; +type AiTextGenerationOutput = { + response?: string; + tool_calls?: { + name: string; + arguments: unknown; + }[]; +}; +declare abstract class BaseAiTextGeneration { + inputs: AiTextGenerationInput; + postProcessedOutputs: AiTextGenerationOutput; +} +type AiTextToSpeechInput = { + prompt: string; + lang?: string; +}; +type AiTextToSpeechOutput = Uint8Array | { + audio: string; +}; +declare abstract class BaseAiTextToSpeech { + inputs: AiTextToSpeechInput; + postProcessedOutputs: AiTextToSpeechOutput; +} +type AiTextToImageInput = { + prompt: string; + negative_prompt?: string; + height?: number; + width?: number; + image?: number[]; + image_b64?: string; + mask?: number[]; + num_steps?: number; + strength?: number; + guidance?: number; + seed?: number; +}; +type AiTextToImageOutput = ReadableStream; +declare abstract class BaseAiTextToImage { + inputs: AiTextToImageInput; + postProcessedOutputs: AiTextToImageOutput; +} +type AiTranslationInput = { + text: string; + target_lang: string; + source_lang?: string; +}; +type AiTranslationOutput = { + translated_text?: string; +}; +declare abstract class BaseAiTranslation { + inputs: AiTranslationInput; + postProcessedOutputs: AiTranslationOutput; +} +type Ai_Cf_Baai_Bge_Base_En_V1_5_Input = { + text: string | string[]; + /** + * The pooling method used in the embedding process. `cls` pooling will generate more accurate embeddings on larger inputs - however, embeddings created with cls pooling are not compatible with embeddings generated with mean pooling. The default pooling method is `mean` in order for this to not be a breaking change, but we highly suggest using the new `cls` pooling for better accuracy. + */ + pooling?: "mean" | "cls"; +} | { + /** + * Batch of the embeddings requests to run using async-queue + */ + requests: { + text: string | string[]; + /** + * The pooling method used in the embedding process. `cls` pooling will generate more accurate embeddings on larger inputs - however, embeddings created with cls pooling are not compatible with embeddings generated with mean pooling. The default pooling method is `mean` in order for this to not be a breaking change, but we highly suggest using the new `cls` pooling for better accuracy. + */ + pooling?: "mean" | "cls"; + }[]; +}; +type Ai_Cf_Baai_Bge_Base_En_V1_5_Output = { + shape?: number[]; + /** + * Embeddings of the requested text values + */ + data?: number[][]; + /** + * The pooling method used in the embedding process. + */ + pooling?: "mean" | "cls"; +} | AsyncResponse; +interface AsyncResponse { + /** + * The async request id that can be used to obtain the results. + */ + request_id?: string; +} +declare abstract class Base_Ai_Cf_Baai_Bge_Base_En_V1_5 { + inputs: Ai_Cf_Baai_Bge_Base_En_V1_5_Input; + postProcessedOutputs: Ai_Cf_Baai_Bge_Base_En_V1_5_Output; +} +type Ai_Cf_Openai_Whisper_Input = string | { + /** + * An array of integers that represent the audio data constrained to 8-bit unsigned integer values + */ + audio: number[]; +}; +interface Ai_Cf_Openai_Whisper_Output { + /** + * The transcription + */ + text: string; + word_count?: number; + words?: { + word?: string; + /** + * The second this word begins in the recording + */ + start?: number; + /** + * The ending second when the word completes + */ + end?: number; + }[]; + vtt?: string; +} +declare abstract class Base_Ai_Cf_Openai_Whisper { + inputs: Ai_Cf_Openai_Whisper_Input; + postProcessedOutputs: Ai_Cf_Openai_Whisper_Output; +} +type Ai_Cf_Meta_M2M100_1_2B_Input = { + /** + * The text to be translated + */ + text: string; + /** + * The language code of the source text (e.g., 'en' for English). Defaults to 'en' if not specified + */ + source_lang?: string; + /** + * The language code to translate the text into (e.g., 'es' for Spanish) + */ + target_lang: string; +} | { + /** + * Batch of the embeddings requests to run using async-queue + */ + requests: { + /** + * The text to be translated + */ + text: string; + /** + * The language code of the source text (e.g., 'en' for English). Defaults to 'en' if not specified + */ + source_lang?: string; + /** + * The language code to translate the text into (e.g., 'es' for Spanish) + */ + target_lang: string; + }[]; +}; +type Ai_Cf_Meta_M2M100_1_2B_Output = { + /** + * The translated text in the target language + */ + translated_text?: string; +} | AsyncResponse; +declare abstract class Base_Ai_Cf_Meta_M2M100_1_2B { + inputs: Ai_Cf_Meta_M2M100_1_2B_Input; + postProcessedOutputs: Ai_Cf_Meta_M2M100_1_2B_Output; +} +type Ai_Cf_Baai_Bge_Small_En_V1_5_Input = { + text: string | string[]; + /** + * The pooling method used in the embedding process. `cls` pooling will generate more accurate embeddings on larger inputs - however, embeddings created with cls pooling are not compatible with embeddings generated with mean pooling. The default pooling method is `mean` in order for this to not be a breaking change, but we highly suggest using the new `cls` pooling for better accuracy. + */ + pooling?: "mean" | "cls"; +} | { + /** + * Batch of the embeddings requests to run using async-queue + */ + requests: { + text: string | string[]; + /** + * The pooling method used in the embedding process. `cls` pooling will generate more accurate embeddings on larger inputs - however, embeddings created with cls pooling are not compatible with embeddings generated with mean pooling. The default pooling method is `mean` in order for this to not be a breaking change, but we highly suggest using the new `cls` pooling for better accuracy. + */ + pooling?: "mean" | "cls"; + }[]; +}; +type Ai_Cf_Baai_Bge_Small_En_V1_5_Output = { + shape?: number[]; + /** + * Embeddings of the requested text values + */ + data?: number[][]; + /** + * The pooling method used in the embedding process. + */ + pooling?: "mean" | "cls"; +} | AsyncResponse; +declare abstract class Base_Ai_Cf_Baai_Bge_Small_En_V1_5 { + inputs: Ai_Cf_Baai_Bge_Small_En_V1_5_Input; + postProcessedOutputs: Ai_Cf_Baai_Bge_Small_En_V1_5_Output; +} +type Ai_Cf_Baai_Bge_Large_En_V1_5_Input = { + text: string | string[]; + /** + * The pooling method used in the embedding process. `cls` pooling will generate more accurate embeddings on larger inputs - however, embeddings created with cls pooling are not compatible with embeddings generated with mean pooling. The default pooling method is `mean` in order for this to not be a breaking change, but we highly suggest using the new `cls` pooling for better accuracy. + */ + pooling?: "mean" | "cls"; +} | { + /** + * Batch of the embeddings requests to run using async-queue + */ + requests: { + text: string | string[]; + /** + * The pooling method used in the embedding process. `cls` pooling will generate more accurate embeddings on larger inputs - however, embeddings created with cls pooling are not compatible with embeddings generated with mean pooling. The default pooling method is `mean` in order for this to not be a breaking change, but we highly suggest using the new `cls` pooling for better accuracy. + */ + pooling?: "mean" | "cls"; + }[]; +}; +type Ai_Cf_Baai_Bge_Large_En_V1_5_Output = { + shape?: number[]; + /** + * Embeddings of the requested text values + */ + data?: number[][]; + /** + * The pooling method used in the embedding process. + */ + pooling?: "mean" | "cls"; +} | AsyncResponse; +declare abstract class Base_Ai_Cf_Baai_Bge_Large_En_V1_5 { + inputs: Ai_Cf_Baai_Bge_Large_En_V1_5_Input; + postProcessedOutputs: Ai_Cf_Baai_Bge_Large_En_V1_5_Output; +} +type Ai_Cf_Unum_Uform_Gen2_Qwen_500M_Input = string | { + /** + * The input text prompt for the model to generate a response. + */ + prompt?: string; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * Controls the creativity of the AI's responses by adjusting how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; + image: number[] | (string & NonNullable); + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; +}; +interface Ai_Cf_Unum_Uform_Gen2_Qwen_500M_Output { + description?: string; +} +declare abstract class Base_Ai_Cf_Unum_Uform_Gen2_Qwen_500M { + inputs: Ai_Cf_Unum_Uform_Gen2_Qwen_500M_Input; + postProcessedOutputs: Ai_Cf_Unum_Uform_Gen2_Qwen_500M_Output; +} +type Ai_Cf_Openai_Whisper_Tiny_En_Input = string | { + /** + * An array of integers that represent the audio data constrained to 8-bit unsigned integer values + */ + audio: number[]; +}; +interface Ai_Cf_Openai_Whisper_Tiny_En_Output { + /** + * The transcription + */ + text: string; + word_count?: number; + words?: { + word?: string; + /** + * The second this word begins in the recording + */ + start?: number; + /** + * The ending second when the word completes + */ + end?: number; + }[]; + vtt?: string; +} +declare abstract class Base_Ai_Cf_Openai_Whisper_Tiny_En { + inputs: Ai_Cf_Openai_Whisper_Tiny_En_Input; + postProcessedOutputs: Ai_Cf_Openai_Whisper_Tiny_En_Output; +} +interface Ai_Cf_Openai_Whisper_Large_V3_Turbo_Input { + /** + * Base64 encoded value of the audio data. + */ + audio: string; + /** + * Supported tasks are 'translate' or 'transcribe'. + */ + task?: string; + /** + * The language of the audio being transcribed or translated. + */ + language?: string; + /** + * Preprocess the audio with a voice activity detection model. + */ + vad_filter?: boolean; + /** + * A text prompt to help provide context to the model on the contents of the audio. + */ + initial_prompt?: string; + /** + * The prefix it appended the the beginning of the output of the transcription and can guide the transcription result. + */ + prefix?: string; +} +interface Ai_Cf_Openai_Whisper_Large_V3_Turbo_Output { + transcription_info?: { + /** + * The language of the audio being transcribed or translated. + */ + language?: string; + /** + * The confidence level or probability of the detected language being accurate, represented as a decimal between 0 and 1. + */ + language_probability?: number; + /** + * The total duration of the original audio file, in seconds. + */ + duration?: number; + /** + * The duration of the audio after applying Voice Activity Detection (VAD) to remove silent or irrelevant sections, in seconds. + */ + duration_after_vad?: number; + }; + /** + * The complete transcription of the audio. + */ + text: string; + /** + * The total number of words in the transcription. + */ + word_count?: number; + segments?: { + /** + * The starting time of the segment within the audio, in seconds. + */ + start?: number; + /** + * The ending time of the segment within the audio, in seconds. + */ + end?: number; + /** + * The transcription of the segment. + */ + text?: string; + /** + * The temperature used in the decoding process, controlling randomness in predictions. Lower values result in more deterministic outputs. + */ + temperature?: number; + /** + * The average log probability of the predictions for the words in this segment, indicating overall confidence. + */ + avg_logprob?: number; + /** + * The compression ratio of the input to the output, measuring how much the text was compressed during the transcription process. + */ + compression_ratio?: number; + /** + * The probability that the segment contains no speech, represented as a decimal between 0 and 1. + */ + no_speech_prob?: number; + words?: { + /** + * The individual word transcribed from the audio. + */ + word?: string; + /** + * The starting time of the word within the audio, in seconds. + */ + start?: number; + /** + * The ending time of the word within the audio, in seconds. + */ + end?: number; + }[]; + }[]; + /** + * The transcription in WebVTT format, which includes timing and text information for use in subtitles. + */ + vtt?: string; +} +declare abstract class Base_Ai_Cf_Openai_Whisper_Large_V3_Turbo { + inputs: Ai_Cf_Openai_Whisper_Large_V3_Turbo_Input; + postProcessedOutputs: Ai_Cf_Openai_Whisper_Large_V3_Turbo_Output; +} +type Ai_Cf_Baai_Bge_M3_Input = BGEM3InputQueryAndContexts | BGEM3InputEmbedding | { + /** + * Batch of the embeddings requests to run using async-queue + */ + requests: (BGEM3InputQueryAndContexts1 | BGEM3InputEmbedding1)[]; +}; +interface BGEM3InputQueryAndContexts { + /** + * A query you wish to perform against the provided contexts. If no query is provided the model with respond with embeddings for contexts + */ + query?: string; + /** + * List of provided contexts. Note that the index in this array is important, as the response will refer to it. + */ + contexts: { + /** + * One of the provided context content + */ + text?: string; + }[]; + /** + * When provided with too long context should the model error out or truncate the context to fit? + */ + truncate_inputs?: boolean; +} +interface BGEM3InputEmbedding { + text: string | string[]; + /** + * When provided with too long context should the model error out or truncate the context to fit? + */ + truncate_inputs?: boolean; +} +interface BGEM3InputQueryAndContexts1 { + /** + * A query you wish to perform against the provided contexts. If no query is provided the model with respond with embeddings for contexts + */ + query?: string; + /** + * List of provided contexts. Note that the index in this array is important, as the response will refer to it. + */ + contexts: { + /** + * One of the provided context content + */ + text?: string; + }[]; + /** + * When provided with too long context should the model error out or truncate the context to fit? + */ + truncate_inputs?: boolean; +} +interface BGEM3InputEmbedding1 { + text: string | string[]; + /** + * When provided with too long context should the model error out or truncate the context to fit? + */ + truncate_inputs?: boolean; +} +type Ai_Cf_Baai_Bge_M3_Output = BGEM3OuputQuery | BGEM3OutputEmbeddingForContexts | BGEM3OuputEmbedding | AsyncResponse; +interface BGEM3OuputQuery { + response?: { + /** + * Index of the context in the request + */ + id?: number; + /** + * Score of the context under the index. + */ + score?: number; + }[]; +} +interface BGEM3OutputEmbeddingForContexts { + response?: number[][]; + shape?: number[]; + /** + * The pooling method used in the embedding process. + */ + pooling?: "mean" | "cls"; +} +interface BGEM3OuputEmbedding { + shape?: number[]; + /** + * Embeddings of the requested text values + */ + data?: number[][]; + /** + * The pooling method used in the embedding process. + */ + pooling?: "mean" | "cls"; +} +declare abstract class Base_Ai_Cf_Baai_Bge_M3 { + inputs: Ai_Cf_Baai_Bge_M3_Input; + postProcessedOutputs: Ai_Cf_Baai_Bge_M3_Output; +} +interface Ai_Cf_Black_Forest_Labs_Flux_1_Schnell_Input { + /** + * A text description of the image you want to generate. + */ + prompt: string; + /** + * The number of diffusion steps; higher values can improve quality but take longer. + */ + steps?: number; +} +interface Ai_Cf_Black_Forest_Labs_Flux_1_Schnell_Output { + /** + * The generated image in Base64 format. + */ + image?: string; +} +declare abstract class Base_Ai_Cf_Black_Forest_Labs_Flux_1_Schnell { + inputs: Ai_Cf_Black_Forest_Labs_Flux_1_Schnell_Input; + postProcessedOutputs: Ai_Cf_Black_Forest_Labs_Flux_1_Schnell_Output; +} +type Ai_Cf_Meta_Llama_3_2_11B_Vision_Instruct_Input = Prompt | Messages; +interface Prompt { + /** + * The input text prompt for the model to generate a response. + */ + prompt: string; + image?: number[] | (string & NonNullable); + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; + /** + * Name of the LoRA (Low-Rank Adaptation) model to fine-tune the base model. + */ + lora?: string; +} +interface Messages { + /** + * An array of message objects representing the conversation history. + */ + messages: { + /** + * The role of the message sender (e.g., 'user', 'assistant', 'system', 'tool'). + */ + role?: string; + /** + * The tool call id. Must be supplied for tool calls for Mistral-3. If you don't know what to put here you can fall back to 000000001 + */ + tool_call_id?: string; + content?: string | { + /** + * Type of the content provided + */ + type?: string; + text?: string; + image_url?: { + /** + * image uri with data (e.g. data:image/jpeg;base64,/9j/...). HTTP URL will not be accepted + */ + url?: string; + }; + }[] | { + /** + * Type of the content provided + */ + type?: string; + text?: string; + image_url?: { + /** + * image uri with data (e.g. data:image/jpeg;base64,/9j/...). HTTP URL will not be accepted + */ + url?: string; + }; + }; + }[]; + image?: number[] | (string & NonNullable); + functions?: { + name: string; + code: string; + }[]; + /** + * A list of tools available for the assistant to use. + */ + tools?: ({ + /** + * The name of the tool. More descriptive the better. + */ + name: string; + /** + * A brief description of what the tool does. + */ + description: string; + /** + * Schema defining the parameters accepted by the tool. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + } | { + /** + * Specifies the type of tool (e.g., 'function'). + */ + type: string; + /** + * Details of the function tool. + */ + function: { + /** + * The name of the function. + */ + name: string; + /** + * A brief description of what the function does. + */ + description: string; + /** + * Schema defining the parameters accepted by the function. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + }; + })[]; + /** + * If true, the response will be streamed back incrementally. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Controls the creativity of the AI's responses by adjusting how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +type Ai_Cf_Meta_Llama_3_2_11B_Vision_Instruct_Output = { + /** + * The generated text response from the model + */ + response?: string; + /** + * An array of tool calls requests made during the response generation + */ + tool_calls?: { + /** + * The arguments passed to be passed to the tool call request + */ + arguments?: object; + /** + * The name of the tool to be called + */ + name?: string; + }[]; +}; +declare abstract class Base_Ai_Cf_Meta_Llama_3_2_11B_Vision_Instruct { + inputs: Ai_Cf_Meta_Llama_3_2_11B_Vision_Instruct_Input; + postProcessedOutputs: Ai_Cf_Meta_Llama_3_2_11B_Vision_Instruct_Output; +} +type Ai_Cf_Meta_Llama_3_3_70B_Instruct_Fp8_Fast_Input = Meta_Llama_3_3_70B_Instruct_Fp8_Fast_Prompt | Meta_Llama_3_3_70B_Instruct_Fp8_Fast_Messages | AsyncBatch; +interface Meta_Llama_3_3_70B_Instruct_Fp8_Fast_Prompt { + /** + * The input text prompt for the model to generate a response. + */ + prompt: string; + /** + * Name of the LoRA (Low-Rank Adaptation) model to fine-tune the base model. + */ + lora?: string; + response_format?: JSONMode; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +interface JSONMode { + type?: "json_object" | "json_schema"; + json_schema?: unknown; +} +interface Meta_Llama_3_3_70B_Instruct_Fp8_Fast_Messages { + /** + * An array of message objects representing the conversation history. + */ + messages: { + /** + * The role of the message sender (e.g., 'user', 'assistant', 'system', 'tool'). + */ + role: string; + /** + * The content of the message as a string. + */ + content: string; + }[]; + functions?: { + name: string; + code: string; + }[]; + /** + * A list of tools available for the assistant to use. + */ + tools?: ({ + /** + * The name of the tool. More descriptive the better. + */ + name: string; + /** + * A brief description of what the tool does. + */ + description: string; + /** + * Schema defining the parameters accepted by the tool. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + } | { + /** + * Specifies the type of tool (e.g., 'function'). + */ + type: string; + /** + * Details of the function tool. + */ + function: { + /** + * The name of the function. + */ + name: string; + /** + * A brief description of what the function does. + */ + description: string; + /** + * Schema defining the parameters accepted by the function. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + }; + })[]; + response_format?: JSONMode; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +interface AsyncBatch { + requests?: { + /** + * User-supplied reference. This field will be present in the response as well it can be used to reference the request and response. It's NOT validated to be unique. + */ + external_reference?: string; + /** + * Prompt for the text generation model + */ + prompt?: string; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; + response_format?: JSONMode; + }[]; +} +type Ai_Cf_Meta_Llama_3_3_70B_Instruct_Fp8_Fast_Output = { + /** + * The generated text response from the model + */ + response: string; + /** + * Usage statistics for the inference request + */ + usage?: { + /** + * Total number of tokens in input + */ + prompt_tokens?: number; + /** + * Total number of tokens in output + */ + completion_tokens?: number; + /** + * Total number of input and output tokens + */ + total_tokens?: number; + }; + /** + * An array of tool calls requests made during the response generation + */ + tool_calls?: { + /** + * The arguments passed to be passed to the tool call request + */ + arguments?: object; + /** + * The name of the tool to be called + */ + name?: string; + }[]; +} | AsyncResponse; +declare abstract class Base_Ai_Cf_Meta_Llama_3_3_70B_Instruct_Fp8_Fast { + inputs: Ai_Cf_Meta_Llama_3_3_70B_Instruct_Fp8_Fast_Input; + postProcessedOutputs: Ai_Cf_Meta_Llama_3_3_70B_Instruct_Fp8_Fast_Output; +} +interface Ai_Cf_Meta_Llama_Guard_3_8B_Input { + /** + * An array of message objects representing the conversation history. + */ + messages: { + /** + * The role of the message sender must alternate between 'user' and 'assistant'. + */ + role: "user" | "assistant"; + /** + * The content of the message as a string. + */ + content: string; + }[]; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Dictate the output format of the generated response. + */ + response_format?: { + /** + * Set to json_object to process and output generated text as JSON. + */ + type?: string; + }; +} +interface Ai_Cf_Meta_Llama_Guard_3_8B_Output { + response?: string | { + /** + * Whether the conversation is safe or not. + */ + safe?: boolean; + /** + * A list of what hazard categories predicted for the conversation, if the conversation is deemed unsafe. + */ + categories?: string[]; + }; + /** + * Usage statistics for the inference request + */ + usage?: { + /** + * Total number of tokens in input + */ + prompt_tokens?: number; + /** + * Total number of tokens in output + */ + completion_tokens?: number; + /** + * Total number of input and output tokens + */ + total_tokens?: number; + }; +} +declare abstract class Base_Ai_Cf_Meta_Llama_Guard_3_8B { + inputs: Ai_Cf_Meta_Llama_Guard_3_8B_Input; + postProcessedOutputs: Ai_Cf_Meta_Llama_Guard_3_8B_Output; +} +interface Ai_Cf_Baai_Bge_Reranker_Base_Input { + /** + * A query you wish to perform against the provided contexts. + */ + query: string; + /** + * Number of returned results starting with the best score. + */ + top_k?: number; + /** + * List of provided contexts. Note that the index in this array is important, as the response will refer to it. + */ + contexts: { + /** + * One of the provided context content + */ + text?: string; + }[]; +} +interface Ai_Cf_Baai_Bge_Reranker_Base_Output { + response?: { + /** + * Index of the context in the request + */ + id?: number; + /** + * Score of the context under the index. + */ + score?: number; + }[]; +} +declare abstract class Base_Ai_Cf_Baai_Bge_Reranker_Base { + inputs: Ai_Cf_Baai_Bge_Reranker_Base_Input; + postProcessedOutputs: Ai_Cf_Baai_Bge_Reranker_Base_Output; +} +type Ai_Cf_Qwen_Qwen2_5_Coder_32B_Instruct_Input = Qwen2_5_Coder_32B_Instruct_Prompt | Qwen2_5_Coder_32B_Instruct_Messages; +interface Qwen2_5_Coder_32B_Instruct_Prompt { + /** + * The input text prompt for the model to generate a response. + */ + prompt: string; + /** + * Name of the LoRA (Low-Rank Adaptation) model to fine-tune the base model. + */ + lora?: string; + response_format?: JSONMode; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +interface Qwen2_5_Coder_32B_Instruct_Messages { + /** + * An array of message objects representing the conversation history. + */ + messages: { + /** + * The role of the message sender (e.g., 'user', 'assistant', 'system', 'tool'). + */ + role: string; + /** + * The content of the message as a string. + */ + content: string; + }[]; + functions?: { + name: string; + code: string; + }[]; + /** + * A list of tools available for the assistant to use. + */ + tools?: ({ + /** + * The name of the tool. More descriptive the better. + */ + name: string; + /** + * A brief description of what the tool does. + */ + description: string; + /** + * Schema defining the parameters accepted by the tool. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + } | { + /** + * Specifies the type of tool (e.g., 'function'). + */ + type: string; + /** + * Details of the function tool. + */ + function: { + /** + * The name of the function. + */ + name: string; + /** + * A brief description of what the function does. + */ + description: string; + /** + * Schema defining the parameters accepted by the function. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + }; + })[]; + response_format?: JSONMode; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +type Ai_Cf_Qwen_Qwen2_5_Coder_32B_Instruct_Output = { + /** + * The generated text response from the model + */ + response: string; + /** + * Usage statistics for the inference request + */ + usage?: { + /** + * Total number of tokens in input + */ + prompt_tokens?: number; + /** + * Total number of tokens in output + */ + completion_tokens?: number; + /** + * Total number of input and output tokens + */ + total_tokens?: number; + }; + /** + * An array of tool calls requests made during the response generation + */ + tool_calls?: { + /** + * The arguments passed to be passed to the tool call request + */ + arguments?: object; + /** + * The name of the tool to be called + */ + name?: string; + }[]; +}; +declare abstract class Base_Ai_Cf_Qwen_Qwen2_5_Coder_32B_Instruct { + inputs: Ai_Cf_Qwen_Qwen2_5_Coder_32B_Instruct_Input; + postProcessedOutputs: Ai_Cf_Qwen_Qwen2_5_Coder_32B_Instruct_Output; +} +type Ai_Cf_Qwen_Qwq_32B_Input = Qwen_Qwq_32B_Prompt | Qwen_Qwq_32B_Messages; +interface Qwen_Qwq_32B_Prompt { + /** + * The input text prompt for the model to generate a response. + */ + prompt: string; + /** + * JSON schema that should be fulfilled for the response. + */ + guided_json?: object; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +interface Qwen_Qwq_32B_Messages { + /** + * An array of message objects representing the conversation history. + */ + messages: { + /** + * The role of the message sender (e.g., 'user', 'assistant', 'system', 'tool'). + */ + role?: string; + /** + * The tool call id. Must be supplied for tool calls for Mistral-3. If you don't know what to put here you can fall back to 000000001 + */ + tool_call_id?: string; + content?: string | { + /** + * Type of the content provided + */ + type?: string; + text?: string; + image_url?: { + /** + * image uri with data (e.g. data:image/jpeg;base64,/9j/...). HTTP URL will not be accepted + */ + url?: string; + }; + }[] | { + /** + * Type of the content provided + */ + type?: string; + text?: string; + image_url?: { + /** + * image uri with data (e.g. data:image/jpeg;base64,/9j/...). HTTP URL will not be accepted + */ + url?: string; + }; + }; + }[]; + functions?: { + name: string; + code: string; + }[]; + /** + * A list of tools available for the assistant to use. + */ + tools?: ({ + /** + * The name of the tool. More descriptive the better. + */ + name: string; + /** + * A brief description of what the tool does. + */ + description: string; + /** + * Schema defining the parameters accepted by the tool. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + } | { + /** + * Specifies the type of tool (e.g., 'function'). + */ + type: string; + /** + * Details of the function tool. + */ + function: { + /** + * The name of the function. + */ + name: string; + /** + * A brief description of what the function does. + */ + description: string; + /** + * Schema defining the parameters accepted by the function. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + }; + })[]; + /** + * JSON schema that should be fufilled for the response. + */ + guided_json?: object; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +type Ai_Cf_Qwen_Qwq_32B_Output = { + /** + * The generated text response from the model + */ + response: string; + /** + * Usage statistics for the inference request + */ + usage?: { + /** + * Total number of tokens in input + */ + prompt_tokens?: number; + /** + * Total number of tokens in output + */ + completion_tokens?: number; + /** + * Total number of input and output tokens + */ + total_tokens?: number; + }; + /** + * An array of tool calls requests made during the response generation + */ + tool_calls?: { + /** + * The arguments passed to be passed to the tool call request + */ + arguments?: object; + /** + * The name of the tool to be called + */ + name?: string; + }[]; +}; +declare abstract class Base_Ai_Cf_Qwen_Qwq_32B { + inputs: Ai_Cf_Qwen_Qwq_32B_Input; + postProcessedOutputs: Ai_Cf_Qwen_Qwq_32B_Output; +} +type Ai_Cf_Mistralai_Mistral_Small_3_1_24B_Instruct_Input = Mistral_Small_3_1_24B_Instruct_Prompt | Mistral_Small_3_1_24B_Instruct_Messages; +interface Mistral_Small_3_1_24B_Instruct_Prompt { + /** + * The input text prompt for the model to generate a response. + */ + prompt: string; + /** + * JSON schema that should be fulfilled for the response. + */ + guided_json?: object; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +interface Mistral_Small_3_1_24B_Instruct_Messages { + /** + * An array of message objects representing the conversation history. + */ + messages: { + /** + * The role of the message sender (e.g., 'user', 'assistant', 'system', 'tool'). + */ + role?: string; + /** + * The tool call id. Must be supplied for tool calls for Mistral-3. If you don't know what to put here you can fall back to 000000001 + */ + tool_call_id?: string; + content?: string | { + /** + * Type of the content provided + */ + type?: string; + text?: string; + image_url?: { + /** + * image uri with data (e.g. data:image/jpeg;base64,/9j/...). HTTP URL will not be accepted + */ + url?: string; + }; + }[] | { + /** + * Type of the content provided + */ + type?: string; + text?: string; + image_url?: { + /** + * image uri with data (e.g. data:image/jpeg;base64,/9j/...). HTTP URL will not be accepted + */ + url?: string; + }; + }; + }[]; + functions?: { + name: string; + code: string; + }[]; + /** + * A list of tools available for the assistant to use. + */ + tools?: ({ + /** + * The name of the tool. More descriptive the better. + */ + name: string; + /** + * A brief description of what the tool does. + */ + description: string; + /** + * Schema defining the parameters accepted by the tool. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + } | { + /** + * Specifies the type of tool (e.g., 'function'). + */ + type: string; + /** + * Details of the function tool. + */ + function: { + /** + * The name of the function. + */ + name: string; + /** + * A brief description of what the function does. + */ + description: string; + /** + * Schema defining the parameters accepted by the function. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + }; + })[]; + /** + * JSON schema that should be fufilled for the response. + */ + guided_json?: object; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +type Ai_Cf_Mistralai_Mistral_Small_3_1_24B_Instruct_Output = { + /** + * The generated text response from the model + */ + response: string; + /** + * Usage statistics for the inference request + */ + usage?: { + /** + * Total number of tokens in input + */ + prompt_tokens?: number; + /** + * Total number of tokens in output + */ + completion_tokens?: number; + /** + * Total number of input and output tokens + */ + total_tokens?: number; + }; + /** + * An array of tool calls requests made during the response generation + */ + tool_calls?: { + /** + * The arguments passed to be passed to the tool call request + */ + arguments?: object; + /** + * The name of the tool to be called + */ + name?: string; + }[]; +}; +declare abstract class Base_Ai_Cf_Mistralai_Mistral_Small_3_1_24B_Instruct { + inputs: Ai_Cf_Mistralai_Mistral_Small_3_1_24B_Instruct_Input; + postProcessedOutputs: Ai_Cf_Mistralai_Mistral_Small_3_1_24B_Instruct_Output; +} +type Ai_Cf_Google_Gemma_3_12B_It_Input = Google_Gemma_3_12B_It_Prompt | Google_Gemma_3_12B_It_Messages; +interface Google_Gemma_3_12B_It_Prompt { + /** + * The input text prompt for the model to generate a response. + */ + prompt: string; + /** + * JSON schema that should be fufilled for the response. + */ + guided_json?: object; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +interface Google_Gemma_3_12B_It_Messages { + /** + * An array of message objects representing the conversation history. + */ + messages: { + /** + * The role of the message sender (e.g., 'user', 'assistant', 'system', 'tool'). + */ + role?: string; + content?: string | { + /** + * Type of the content provided + */ + type?: string; + text?: string; + image_url?: { + /** + * image uri with data (e.g. data:image/jpeg;base64,/9j/...). HTTP URL will not be accepted + */ + url?: string; + }; + }[] | { + /** + * Type of the content provided + */ + type?: string; + text?: string; + image_url?: { + /** + * image uri with data (e.g. data:image/jpeg;base64,/9j/...). HTTP URL will not be accepted + */ + url?: string; + }; + }; + }[]; + functions?: { + name: string; + code: string; + }[]; + /** + * A list of tools available for the assistant to use. + */ + tools?: ({ + /** + * The name of the tool. More descriptive the better. + */ + name: string; + /** + * A brief description of what the tool does. + */ + description: string; + /** + * Schema defining the parameters accepted by the tool. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + } | { + /** + * Specifies the type of tool (e.g., 'function'). + */ + type: string; + /** + * Details of the function tool. + */ + function: { + /** + * The name of the function. + */ + name: string; + /** + * A brief description of what the function does. + */ + description: string; + /** + * Schema defining the parameters accepted by the function. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + }; + })[]; + /** + * JSON schema that should be fufilled for the response. + */ + guided_json?: object; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +type Ai_Cf_Google_Gemma_3_12B_It_Output = { + /** + * The generated text response from the model + */ + response: string; + /** + * Usage statistics for the inference request + */ + usage?: { + /** + * Total number of tokens in input + */ + prompt_tokens?: number; + /** + * Total number of tokens in output + */ + completion_tokens?: number; + /** + * Total number of input and output tokens + */ + total_tokens?: number; + }; + /** + * An array of tool calls requests made during the response generation + */ + tool_calls?: { + /** + * The arguments passed to be passed to the tool call request + */ + arguments?: object; + /** + * The name of the tool to be called + */ + name?: string; + }[]; +}; +declare abstract class Base_Ai_Cf_Google_Gemma_3_12B_It { + inputs: Ai_Cf_Google_Gemma_3_12B_It_Input; + postProcessedOutputs: Ai_Cf_Google_Gemma_3_12B_It_Output; +} +type Ai_Cf_Meta_Llama_4_Scout_17B_16E_Instruct_Input = Ai_Cf_Meta_Llama_4_Prompt | Ai_Cf_Meta_Llama_4_Messages; +interface Ai_Cf_Meta_Llama_4_Prompt { + /** + * The input text prompt for the model to generate a response. + */ + prompt: string; + /** + * JSON schema that should be fulfilled for the response. + */ + guided_json?: object; + response_format?: JSONMode; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +interface Ai_Cf_Meta_Llama_4_Messages { + /** + * An array of message objects representing the conversation history. + */ + messages: { + /** + * The role of the message sender (e.g., 'user', 'assistant', 'system', 'tool'). + */ + role?: string; + /** + * The tool call id. If you don't know what to put here you can fall back to 000000001 + */ + tool_call_id?: string; + content?: string | { + /** + * Type of the content provided + */ + type?: string; + text?: string; + image_url?: { + /** + * image uri with data (e.g. data:image/jpeg;base64,/9j/...). HTTP URL will not be accepted + */ + url?: string; + }; + }[] | { + /** + * Type of the content provided + */ + type?: string; + text?: string; + image_url?: { + /** + * image uri with data (e.g. data:image/jpeg;base64,/9j/...). HTTP URL will not be accepted + */ + url?: string; + }; + }; + }[]; + functions?: { + name: string; + code: string; + }[]; + /** + * A list of tools available for the assistant to use. + */ + tools?: ({ + /** + * The name of the tool. More descriptive the better. + */ + name: string; + /** + * A brief description of what the tool does. + */ + description: string; + /** + * Schema defining the parameters accepted by the tool. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + } | { + /** + * Specifies the type of tool (e.g., 'function'). + */ + type: string; + /** + * Details of the function tool. + */ + function: { + /** + * The name of the function. + */ + name: string; + /** + * A brief description of what the function does. + */ + description: string; + /** + * Schema defining the parameters accepted by the function. + */ + parameters: { + /** + * The type of the parameters object (usually 'object'). + */ + type: string; + /** + * List of required parameter names. + */ + required?: string[]; + /** + * Definitions of each parameter. + */ + properties: { + [k: string]: { + /** + * The data type of the parameter. + */ + type: string; + /** + * A description of the expected parameter. + */ + description: string; + }; + }; + }; + }; + })[]; + response_format?: JSONMode; + /** + * JSON schema that should be fufilled for the response. + */ + guided_json?: object; + /** + * If true, a chat template is not applied and you must adhere to the specific model's expected formatting. + */ + raw?: boolean; + /** + * If true, the response will be streamed back incrementally using SSE, Server Sent Events. + */ + stream?: boolean; + /** + * The maximum number of tokens to generate in the response. + */ + max_tokens?: number; + /** + * Controls the randomness of the output; higher values produce more random results. + */ + temperature?: number; + /** + * Adjusts the creativity of the AI's responses by controlling how many possible words it considers. Lower values make outputs more predictable; higher values allow for more varied and creative responses. + */ + top_p?: number; + /** + * Limits the AI to choose from the top 'k' most probable words. Lower values make responses more focused; higher values introduce more variety and potential surprises. + */ + top_k?: number; + /** + * Random seed for reproducibility of the generation. + */ + seed?: number; + /** + * Penalty for repeated tokens; higher values discourage repetition. + */ + repetition_penalty?: number; + /** + * Decreases the likelihood of the model repeating the same lines verbatim. + */ + frequency_penalty?: number; + /** + * Increases the likelihood of the model introducing new topics. + */ + presence_penalty?: number; +} +type Ai_Cf_Meta_Llama_4_Scout_17B_16E_Instruct_Output = { + /** + * The generated text response from the model + */ + response: string; + /** + * Usage statistics for the inference request + */ + usage?: { + /** + * Total number of tokens in input + */ + prompt_tokens?: number; + /** + * Total number of tokens in output + */ + completion_tokens?: number; + /** + * Total number of input and output tokens + */ + total_tokens?: number; + }; + /** + * An array of tool calls requests made during the response generation + */ + tool_calls?: { + /** + * The tool call id. + */ + id?: string; + /** + * Specifies the type of tool (e.g., 'function'). + */ + type?: string; + /** + * Details of the function tool. + */ + function?: { + /** + * The name of the tool to be called + */ + name?: string; + /** + * The arguments passed to be passed to the tool call request + */ + arguments?: object; + }; + }[]; +}; +declare abstract class Base_Ai_Cf_Meta_Llama_4_Scout_17B_16E_Instruct { + inputs: Ai_Cf_Meta_Llama_4_Scout_17B_16E_Instruct_Input; + postProcessedOutputs: Ai_Cf_Meta_Llama_4_Scout_17B_16E_Instruct_Output; +} +interface AiModels { + "@cf/huggingface/distilbert-sst-2-int8": BaseAiTextClassification; + "@cf/stabilityai/stable-diffusion-xl-base-1.0": BaseAiTextToImage; + "@cf/runwayml/stable-diffusion-v1-5-inpainting": BaseAiTextToImage; + "@cf/runwayml/stable-diffusion-v1-5-img2img": BaseAiTextToImage; + "@cf/lykon/dreamshaper-8-lcm": BaseAiTextToImage; + "@cf/bytedance/stable-diffusion-xl-lightning": BaseAiTextToImage; + "@cf/myshell-ai/melotts": BaseAiTextToSpeech; + "@cf/microsoft/resnet-50": BaseAiImageClassification; + "@cf/facebook/detr-resnet-50": BaseAiObjectDetection; + "@cf/meta/llama-2-7b-chat-int8": BaseAiTextGeneration; + "@cf/mistral/mistral-7b-instruct-v0.1": BaseAiTextGeneration; + "@cf/meta/llama-2-7b-chat-fp16": BaseAiTextGeneration; + "@hf/thebloke/llama-2-13b-chat-awq": BaseAiTextGeneration; + "@hf/thebloke/mistral-7b-instruct-v0.1-awq": BaseAiTextGeneration; + "@hf/thebloke/zephyr-7b-beta-awq": BaseAiTextGeneration; + "@hf/thebloke/openhermes-2.5-mistral-7b-awq": BaseAiTextGeneration; + "@hf/thebloke/neural-chat-7b-v3-1-awq": BaseAiTextGeneration; + "@hf/thebloke/llamaguard-7b-awq": BaseAiTextGeneration; + "@hf/thebloke/deepseek-coder-6.7b-base-awq": BaseAiTextGeneration; + "@hf/thebloke/deepseek-coder-6.7b-instruct-awq": BaseAiTextGeneration; + "@cf/deepseek-ai/deepseek-math-7b-instruct": BaseAiTextGeneration; + "@cf/defog/sqlcoder-7b-2": BaseAiTextGeneration; + "@cf/openchat/openchat-3.5-0106": BaseAiTextGeneration; + "@cf/tiiuae/falcon-7b-instruct": BaseAiTextGeneration; + "@cf/thebloke/discolm-german-7b-v1-awq": BaseAiTextGeneration; + "@cf/qwen/qwen1.5-0.5b-chat": BaseAiTextGeneration; + "@cf/qwen/qwen1.5-7b-chat-awq": BaseAiTextGeneration; + "@cf/qwen/qwen1.5-14b-chat-awq": BaseAiTextGeneration; + "@cf/tinyllama/tinyllama-1.1b-chat-v1.0": BaseAiTextGeneration; + "@cf/microsoft/phi-2": BaseAiTextGeneration; + "@cf/qwen/qwen1.5-1.8b-chat": BaseAiTextGeneration; + "@cf/mistral/mistral-7b-instruct-v0.2-lora": BaseAiTextGeneration; + "@hf/nousresearch/hermes-2-pro-mistral-7b": BaseAiTextGeneration; + "@hf/nexusflow/starling-lm-7b-beta": BaseAiTextGeneration; + "@hf/google/gemma-7b-it": BaseAiTextGeneration; + "@cf/meta-llama/llama-2-7b-chat-hf-lora": BaseAiTextGeneration; + "@cf/google/gemma-2b-it-lora": BaseAiTextGeneration; + "@cf/google/gemma-7b-it-lora": BaseAiTextGeneration; + "@hf/mistral/mistral-7b-instruct-v0.2": BaseAiTextGeneration; + "@cf/meta/llama-3-8b-instruct": BaseAiTextGeneration; + "@cf/fblgit/una-cybertron-7b-v2-bf16": BaseAiTextGeneration; + "@cf/meta/llama-3-8b-instruct-awq": BaseAiTextGeneration; + "@hf/meta-llama/meta-llama-3-8b-instruct": BaseAiTextGeneration; + "@cf/meta/llama-3.1-8b-instruct": BaseAiTextGeneration; + "@cf/meta/llama-3.1-8b-instruct-fp8": BaseAiTextGeneration; + "@cf/meta/llama-3.1-8b-instruct-awq": BaseAiTextGeneration; + "@cf/meta/llama-3.2-3b-instruct": BaseAiTextGeneration; + "@cf/meta/llama-3.2-1b-instruct": BaseAiTextGeneration; + "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b": BaseAiTextGeneration; + "@cf/facebook/bart-large-cnn": BaseAiSummarization; + "@cf/llava-hf/llava-1.5-7b-hf": BaseAiImageToText; + "@cf/baai/bge-base-en-v1.5": Base_Ai_Cf_Baai_Bge_Base_En_V1_5; + "@cf/openai/whisper": Base_Ai_Cf_Openai_Whisper; + "@cf/meta/m2m100-1.2b": Base_Ai_Cf_Meta_M2M100_1_2B; + "@cf/baai/bge-small-en-v1.5": Base_Ai_Cf_Baai_Bge_Small_En_V1_5; + "@cf/baai/bge-large-en-v1.5": Base_Ai_Cf_Baai_Bge_Large_En_V1_5; + "@cf/unum/uform-gen2-qwen-500m": Base_Ai_Cf_Unum_Uform_Gen2_Qwen_500M; + "@cf/openai/whisper-tiny-en": Base_Ai_Cf_Openai_Whisper_Tiny_En; + "@cf/openai/whisper-large-v3-turbo": Base_Ai_Cf_Openai_Whisper_Large_V3_Turbo; + "@cf/baai/bge-m3": Base_Ai_Cf_Baai_Bge_M3; + "@cf/black-forest-labs/flux-1-schnell": Base_Ai_Cf_Black_Forest_Labs_Flux_1_Schnell; + "@cf/meta/llama-3.2-11b-vision-instruct": Base_Ai_Cf_Meta_Llama_3_2_11B_Vision_Instruct; + "@cf/meta/llama-3.3-70b-instruct-fp8-fast": Base_Ai_Cf_Meta_Llama_3_3_70B_Instruct_Fp8_Fast; + "@cf/meta/llama-guard-3-8b": Base_Ai_Cf_Meta_Llama_Guard_3_8B; + "@cf/baai/bge-reranker-base": Base_Ai_Cf_Baai_Bge_Reranker_Base; + "@cf/qwen/qwen2.5-coder-32b-instruct": Base_Ai_Cf_Qwen_Qwen2_5_Coder_32B_Instruct; + "@cf/qwen/qwq-32b": Base_Ai_Cf_Qwen_Qwq_32B; + "@cf/mistralai/mistral-small-3.1-24b-instruct": Base_Ai_Cf_Mistralai_Mistral_Small_3_1_24B_Instruct; + "@cf/google/gemma-3-12b-it": Base_Ai_Cf_Google_Gemma_3_12B_It; + "@cf/meta/llama-4-scout-17b-16e-instruct": Base_Ai_Cf_Meta_Llama_4_Scout_17B_16E_Instruct; +} +type AiOptions = { + /** + * Send requests as an asynchronous batch job, only works for supported models + * https://developers.cloudflare.com/workers-ai/features/batch-api + */ + queueRequest?: boolean; + gateway?: GatewayOptions; + returnRawResponse?: boolean; + prefix?: string; + extraHeaders?: object; +}; +type ConversionResponse = { + name: string; + mimeType: string; + format: "markdown"; + tokens: number; + data: string; +}; +type AiModelsSearchParams = { + author?: string; + hide_experimental?: boolean; + page?: number; + per_page?: number; + search?: string; + source?: number; + task?: string; +}; +type AiModelsSearchObject = { + id: string; + source: number; + name: string; + description: string; + task: { + id: string; + name: string; + description: string; + }; + tags: string[]; + properties: { + property_id: string; + value: string; + }[]; +}; +interface InferenceUpstreamError extends Error { +} +interface AiInternalError extends Error { +} +type AiModelListType = Record; +declare abstract class Ai { + aiGatewayLogId: string | null; + gateway(gatewayId: string): AiGateway; + autorag(autoragId?: string): AutoRAG; + run(model: Name, inputs: InputOptions, options?: Options): Promise; + models(params?: AiModelsSearchParams): Promise; + toMarkdown(files: { + name: string; + blob: Blob; + }[], options?: { + gateway?: GatewayOptions; + extraHeaders?: object; + }): Promise; + toMarkdown(files: { + name: string; + blob: Blob; + }, options?: { + gateway?: GatewayOptions; + extraHeaders?: object; + }): Promise; +} +type GatewayRetries = { + maxAttempts?: 1 | 2 | 3 | 4 | 5; + retryDelayMs?: number; + backoff?: 'constant' | 'linear' | 'exponential'; +}; +type GatewayOptions = { + id: string; + cacheKey?: string; + cacheTtl?: number; + skipCache?: boolean; + metadata?: Record; + collectLog?: boolean; + eventId?: string; + requestTimeoutMs?: number; + retries?: GatewayRetries; +}; +type AiGatewayPatchLog = { + score?: number | null; + feedback?: -1 | 1 | null; + metadata?: Record | null; +}; +type AiGatewayLog = { + id: string; + provider: string; + model: string; + model_type?: string; + path: string; + duration: number; + request_type?: string; + request_content_type?: string; + status_code: number; + response_content_type?: string; + success: boolean; + cached: boolean; + tokens_in?: number; + tokens_out?: number; + metadata?: Record; + step?: number; + cost?: number; + custom_cost?: boolean; + request_size: number; + request_head?: string; + request_head_complete: boolean; + response_size: number; + response_head?: string; + response_head_complete: boolean; + created_at: Date; +}; +type AIGatewayProviders = 'workers-ai' | 'anthropic' | 'aws-bedrock' | 'azure-openai' | 'google-vertex-ai' | 'huggingface' | 'openai' | 'perplexity-ai' | 'replicate' | 'groq' | 'cohere' | 'google-ai-studio' | 'mistral' | 'grok' | 'openrouter' | 'deepseek' | 'cerebras' | 'cartesia' | 'elevenlabs' | 'adobe-firefly'; +type AIGatewayHeaders = { + 'cf-aig-metadata': Record | string; + 'cf-aig-custom-cost': { + per_token_in?: number; + per_token_out?: number; + } | { + total_cost?: number; + } | string; + 'cf-aig-cache-ttl': number | string; + 'cf-aig-skip-cache': boolean | string; + 'cf-aig-cache-key': string; + 'cf-aig-event-id': string; + 'cf-aig-request-timeout': number | string; + 'cf-aig-max-attempts': number | string; + 'cf-aig-retry-delay': number | string; + 'cf-aig-backoff': string; + 'cf-aig-collect-log': boolean | string; + Authorization: string; + 'Content-Type': string; + [key: string]: string | number | boolean | object; +}; +type AIGatewayUniversalRequest = { + provider: AIGatewayProviders | string; // eslint-disable-line + endpoint: string; + headers: Partial; + query: unknown; +}; +interface AiGatewayInternalError extends Error { +} +interface AiGatewayLogNotFound extends Error { +} +declare abstract class AiGateway { + patchLog(logId: string, data: AiGatewayPatchLog): Promise; + getLog(logId: string): Promise; + run(data: AIGatewayUniversalRequest | AIGatewayUniversalRequest[], options?: { + gateway?: GatewayOptions; + extraHeaders?: object; + }): Promise; + getUrl(provider?: AIGatewayProviders | string): Promise; // eslint-disable-line +} +interface AutoRAGInternalError extends Error { +} +interface AutoRAGNotFoundError extends Error { +} +interface AutoRAGUnauthorizedError extends Error { +} +interface AutoRAGNameNotSetError extends Error { +} +type ComparisonFilter = { + key: string; + type: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte'; + value: string | number | boolean; +}; +type CompoundFilter = { + type: 'and' | 'or'; + filters: ComparisonFilter[]; +}; +type AutoRagSearchRequest = { + query: string; + filters?: CompoundFilter | ComparisonFilter; + max_num_results?: number; + ranking_options?: { + ranker?: string; + score_threshold?: number; + }; + rewrite_query?: boolean; +}; +type AutoRagAiSearchRequest = AutoRagSearchRequest & { + stream?: boolean; +}; +type AutoRagAiSearchRequestStreaming = Omit & { + stream: true; +}; +type AutoRagSearchResponse = { + object: 'vector_store.search_results.page'; + search_query: string; + data: { + file_id: string; + filename: string; + score: number; + attributes: Record; + content: { + type: 'text'; + text: string; + }[]; + }[]; + has_more: boolean; + next_page: string | null; +}; +type AutoRagListResponse = { + id: string; + enable: boolean; + type: string; + source: string; + vectorize_name: string; + paused: boolean; + status: string; +}[]; +type AutoRagAiSearchResponse = AutoRagSearchResponse & { + response: string; +}; +declare abstract class AutoRAG { + list(): Promise; + search(params: AutoRagSearchRequest): Promise; + aiSearch(params: AutoRagAiSearchRequestStreaming): Promise; + aiSearch(params: AutoRagAiSearchRequest): Promise; + aiSearch(params: AutoRagAiSearchRequest): Promise; +} +interface BasicImageTransformations { + /** + * Maximum width in image pixels. The value must be an integer. + */ + width?: number; + /** + * Maximum height in image pixels. The value must be an integer. + */ + height?: number; + /** + * Resizing mode as a string. It affects interpretation of width and height + * options: + * - scale-down: Similar to contain, but the image is never enlarged. If + * the image is larger than given width or height, it will be resized. + * Otherwise its original size will be kept. + * - contain: Resizes to maximum size that fits within the given width and + * height. If only a single dimension is given (e.g. only width), the + * image will be shrunk or enlarged to exactly match that dimension. + * Aspect ratio is always preserved. + * - cover: Resizes (shrinks or enlarges) to fill the entire area of width + * and height. If the image has an aspect ratio different from the ratio + * of width and height, it will be cropped to fit. + * - crop: The image will be shrunk and cropped to fit within the area + * specified by width and height. The image will not be enlarged. For images + * smaller than the given dimensions it's the same as scale-down. For + * images larger than the given dimensions, it's the same as cover. + * See also trim. + * - pad: Resizes to the maximum size that fits within the given width and + * height, and then fills the remaining area with a background color + * (white by default). Use of this mode is not recommended, as the same + * effect can be more efficiently achieved with the contain mode and the + * CSS object-fit: contain property. + * - squeeze: Stretches and deforms to the width and height given, even if it + * breaks aspect ratio + */ + fit?: "scale-down" | "contain" | "cover" | "crop" | "pad" | "squeeze"; + /** + * When cropping with fit: "cover", this defines the side or point that should + * be left uncropped. The value is either a string + * "left", "right", "top", "bottom", "auto", or "center" (the default), + * or an object {x, y} containing focal point coordinates in the original + * image expressed as fractions ranging from 0.0 (top or left) to 1.0 + * (bottom or right), 0.5 being the center. {fit: "cover", gravity: "top"} will + * crop bottom or left and right sides as necessary, but won’t crop anything + * from the top. {fit: "cover", gravity: {x:0.5, y:0.2}} will crop each side to + * preserve as much as possible around a point at 20% of the height of the + * source image. + */ + gravity?: 'left' | 'right' | 'top' | 'bottom' | 'center' | 'auto' | 'entropy' | BasicImageTransformationsGravityCoordinates; + /** + * Background color to add underneath the image. Applies only to images with + * transparency (such as PNG). Accepts any CSS color (#RRGGBB, rgba(…), + * hsl(…), etc.) + */ + background?: string; + /** + * Number of degrees (90, 180, 270) to rotate the image by. width and height + * options refer to axes after rotation. + */ + rotate?: 0 | 90 | 180 | 270 | 360; +} +interface BasicImageTransformationsGravityCoordinates { + x?: number; + y?: number; + mode?: 'remainder' | 'box-center'; +} +/** + * In addition to the properties you can set in the RequestInit dict + * that you pass as an argument to the Request constructor, you can + * set certain properties of a `cf` object to control how Cloudflare + * features are applied to that new Request. + * + * Note: Currently, these properties cannot be tested in the + * playground. + */ +interface RequestInitCfProperties extends Record { + cacheEverything?: boolean; + /** + * A request's cache key is what determines if two requests are + * "the same" for caching purposes. If a request has the same cache key + * as some previous request, then we can serve the same cached response for + * both. (e.g. 'some-key') + * + * Only available for Enterprise customers. + */ + cacheKey?: string; + /** + * This allows you to append additional Cache-Tag response headers + * to the origin response without modifications to the origin server. + * This will allow for greater control over the Purge by Cache Tag feature + * utilizing changes only in the Workers process. + * + * Only available for Enterprise customers. + */ + cacheTags?: string[]; + /** + * Force response to be cached for a given number of seconds. (e.g. 300) + */ + cacheTtl?: number; + /** + * Force response to be cached for a given number of seconds based on the Origin status code. + * (e.g. { '200-299': 86400, '404': 1, '500-599': 0 }) + */ + cacheTtlByStatus?: Record; + scrapeShield?: boolean; + apps?: boolean; + image?: RequestInitCfPropertiesImage; + minify?: RequestInitCfPropertiesImageMinify; + mirage?: boolean; + polish?: "lossy" | "lossless" | "off"; + r2?: RequestInitCfPropertiesR2; + /** + * Redirects the request to an alternate origin server. You can use this, + * for example, to implement load balancing across several origins. + * (e.g.us-east.example.com) + * + * Note - For security reasons, the hostname set in resolveOverride must + * be proxied on the same Cloudflare zone of the incoming request. + * Otherwise, the setting is ignored. CNAME hosts are allowed, so to + * resolve to a host under a different domain or a DNS only domain first + * declare a CNAME record within your own zone’s DNS mapping to the + * external hostname, set proxy on Cloudflare, then set resolveOverride + * to point to that CNAME record. + */ + resolveOverride?: string; +} +interface RequestInitCfPropertiesImageDraw extends BasicImageTransformations { + /** + * Absolute URL of the image file to use for the drawing. It can be any of + * the supported file formats. For drawing of watermarks or non-rectangular + * overlays we recommend using PNG or WebP images. + */ + url: string; + /** + * Floating-point number between 0 (transparent) and 1 (opaque). + * For example, opacity: 0.5 makes overlay semitransparent. + */ + opacity?: number; + /** + * - If set to true, the overlay image will be tiled to cover the entire + * area. This is useful for stock-photo-like watermarks. + * - If set to "x", the overlay image will be tiled horizontally only + * (form a line). + * - If set to "y", the overlay image will be tiled vertically only + * (form a line). + */ + repeat?: true | "x" | "y"; + /** + * Position of the overlay image relative to a given edge. Each property is + * an offset in pixels. 0 aligns exactly to the edge. For example, left: 10 + * positions left side of the overlay 10 pixels from the left edge of the + * image it's drawn over. bottom: 0 aligns bottom of the overlay with bottom + * of the background image. + * + * Setting both left & right, or both top & bottom is an error. + * + * If no position is specified, the image will be centered. + */ + top?: number; + left?: number; + bottom?: number; + right?: number; +} +interface RequestInitCfPropertiesImage extends BasicImageTransformations { + /** + * Device Pixel Ratio. Default 1. Multiplier for width/height that makes it + * easier to specify higher-DPI sizes in . + */ + dpr?: number; + /** + * Allows you to trim your image. Takes dpr into account and is performed before + * resizing or rotation. + * + * It can be used as: + * - left, top, right, bottom - it will specify the number of pixels to cut + * off each side + * - width, height - the width/height you'd like to end up with - can be used + * in combination with the properties above + * - border - this will automatically trim the surroundings of an image based on + * it's color. It consists of three properties: + * - color: rgb or hex representation of the color you wish to trim (todo: verify the rgba bit) + * - tolerance: difference from color to treat as color + * - keep: the number of pixels of border to keep + */ + trim?: "border" | { + top?: number; + bottom?: number; + left?: number; + right?: number; + width?: number; + height?: number; + border?: boolean | { + color?: string; + tolerance?: number; + keep?: number; + }; + }; + /** + * Quality setting from 1-100 (useful values are in 60-90 range). Lower values + * make images look worse, but load faster. The default is 85. It applies only + * to JPEG and WebP images. It doesn’t have any effect on PNG. + */ + quality?: number | "low" | "medium-low" | "medium-high" | "high"; + /** + * Output format to generate. It can be: + * - avif: generate images in AVIF format. + * - webp: generate images in Google WebP format. Set quality to 100 to get + * the WebP-lossless format. + * - json: instead of generating an image, outputs information about the + * image, in JSON format. The JSON object will contain image size + * (before and after resizing), source image’s MIME type, file size, etc. + * - jpeg: generate images in JPEG format. + * - png: generate images in PNG format. + */ + format?: "avif" | "webp" | "json" | "jpeg" | "png" | "baseline-jpeg" | "png-force" | "svg"; + /** + * Whether to preserve animation frames from input files. Default is true. + * Setting it to false reduces animations to still images. This setting is + * recommended when enlarging images or processing arbitrary user content, + * because large GIF animations can weigh tens or even hundreds of megabytes. + * It is also useful to set anim:false when using format:"json" to get the + * response quicker without the number of frames. + */ + anim?: boolean; + /** + * What EXIF data should be preserved in the output image. Note that EXIF + * rotation and embedded color profiles are always applied ("baked in" into + * the image), and aren't affected by this option. Note that if the Polish + * feature is enabled, all metadata may have been removed already and this + * option may have no effect. + * - keep: Preserve most of EXIF metadata, including GPS location if there's + * any. + * - copyright: Only keep the copyright tag, and discard everything else. + * This is the default behavior for JPEG files. + * - none: Discard all invisible EXIF metadata. Currently WebP and PNG + * output formats always discard metadata. + */ + metadata?: "keep" | "copyright" | "none"; + /** + * Strength of sharpening filter to apply to the image. Floating-point + * number between 0 (no sharpening, default) and 10 (maximum). 1.0 is a + * recommended value for downscaled images. + */ + sharpen?: number; + /** + * Radius of a blur filter (approximate gaussian). Maximum supported radius + * is 250. + */ + blur?: number; + /** + * Overlays are drawn in the order they appear in the array (last array + * entry is the topmost layer). + */ + draw?: RequestInitCfPropertiesImageDraw[]; + /** + * Fetching image from authenticated origin. Setting this property will + * pass authentication headers (Authorization, Cookie, etc.) through to + * the origin. + */ + "origin-auth"?: "share-publicly"; + /** + * Adds a border around the image. The border is added after resizing. Border + * width takes dpr into account, and can be specified either using a single + * width property, or individually for each side. + */ + border?: { + color: string; + width: number; + } | { + color: string; + top: number; + right: number; + bottom: number; + left: number; + }; + /** + * Increase brightness by a factor. A value of 1.0 equals no change, a value + * of 0.5 equals half brightness, and a value of 2.0 equals twice as bright. + * 0 is ignored. + */ + brightness?: number; + /** + * Increase contrast by a factor. A value of 1.0 equals no change, a value of + * 0.5 equals low contrast, and a value of 2.0 equals high contrast. 0 is + * ignored. + */ + contrast?: number; + /** + * Increase exposure by a factor. A value of 1.0 equals no change, a value of + * 0.5 darkens the image, and a value of 2.0 lightens the image. 0 is ignored. + */ + gamma?: number; + /** + * Increase contrast by a factor. A value of 1.0 equals no change, a value of + * 0.5 equals low contrast, and a value of 2.0 equals high contrast. 0 is + * ignored. + */ + saturation?: number; + /** + * Flips the images horizontally, vertically, or both. Flipping is applied before + * rotation, so if you apply flip=h,rotate=90 then the image will be flipped + * horizontally, then rotated by 90 degrees. + */ + flip?: 'h' | 'v' | 'hv'; + /** + * Slightly reduces latency on a cache miss by selecting a + * quickest-to-compress file format, at a cost of increased file size and + * lower image quality. It will usually override the format option and choose + * JPEG over WebP or AVIF. We do not recommend using this option, except in + * unusual circumstances like resizing uncacheable dynamically-generated + * images. + */ + compression?: "fast"; +} +interface RequestInitCfPropertiesImageMinify { + javascript?: boolean; + css?: boolean; + html?: boolean; +} +interface RequestInitCfPropertiesR2 { + /** + * Colo id of bucket that an object is stored in + */ + bucketColoId?: number; +} +/** + * Request metadata provided by Cloudflare's edge. + */ +type IncomingRequestCfProperties = IncomingRequestCfPropertiesBase & IncomingRequestCfPropertiesBotManagementEnterprise & IncomingRequestCfPropertiesCloudflareForSaaSEnterprise & IncomingRequestCfPropertiesGeographicInformation & IncomingRequestCfPropertiesCloudflareAccessOrApiShield; +interface IncomingRequestCfPropertiesBase extends Record { + /** + * [ASN](https://www.iana.org/assignments/as-numbers/as-numbers.xhtml) of the incoming request. + * + * @example 395747 + */ + asn: number; + /** + * The organization which owns the ASN of the incoming request. + * + * @example "Google Cloud" + */ + asOrganization: string; + /** + * The original value of the `Accept-Encoding` header if Cloudflare modified it. + * + * @example "gzip, deflate, br" + */ + clientAcceptEncoding?: string; + /** + * The number of milliseconds it took for the request to reach your worker. + * + * @example 22 + */ + clientTcpRtt?: number; + /** + * The three-letter [IATA](https://en.wikipedia.org/wiki/IATA_airport_code) + * airport code of the data center that the request hit. + * + * @example "DFW" + */ + colo: string; + /** + * Represents the upstream's response to a + * [TCP `keepalive` message](https://tldp.org/HOWTO/TCP-Keepalive-HOWTO/overview.html) + * from cloudflare. + * + * For workers with no upstream, this will always be `1`. + * + * @example 3 + */ + edgeRequestKeepAliveStatus: IncomingRequestCfPropertiesEdgeRequestKeepAliveStatus; + /** + * The HTTP Protocol the request used. + * + * @example "HTTP/2" + */ + httpProtocol: string; + /** + * The browser-requested prioritization information in the request object. + * + * If no information was set, defaults to the empty string `""` + * + * @example "weight=192;exclusive=0;group=3;group-weight=127" + * @default "" + */ + requestPriority: string; + /** + * The TLS version of the connection to Cloudflare. + * In requests served over plaintext (without TLS), this property is the empty string `""`. + * + * @example "TLSv1.3" + */ + tlsVersion: string; + /** + * The cipher for the connection to Cloudflare. + * In requests served over plaintext (without TLS), this property is the empty string `""`. + * + * @example "AEAD-AES128-GCM-SHA256" + */ + tlsCipher: string; + /** + * Metadata containing the [`HELLO`](https://www.rfc-editor.org/rfc/rfc5246#section-7.4.1.2) and [`FINISHED`](https://www.rfc-editor.org/rfc/rfc5246#section-7.4.9) messages from this request's TLS handshake. + * + * If the incoming request was served over plaintext (without TLS) this field is undefined. + */ + tlsExportedAuthenticator?: IncomingRequestCfPropertiesExportedAuthenticatorMetadata; +} +interface IncomingRequestCfPropertiesBotManagementBase { + /** + * Cloudflare’s [level of certainty](https://developers.cloudflare.com/bots/concepts/bot-score/) that a request comes from a bot, + * represented as an integer percentage between `1` (almost certainly a bot) and `99` (almost certainly human). + * + * @example 54 + */ + score: number; + /** + * A boolean value that is true if the request comes from a good bot, like Google or Bing. + * Most customers choose to allow this traffic. For more details, see [Traffic from known bots](https://developers.cloudflare.com/firewall/known-issues-and-faq/#how-does-firewall-rules-handle-traffic-from-known-bots). + */ + verifiedBot: boolean; + /** + * A boolean value that is true if the request originates from a + * Cloudflare-verified proxy service. + */ + corporateProxy: boolean; + /** + * A boolean value that's true if the request matches [file extensions](https://developers.cloudflare.com/bots/reference/static-resources/) for many types of static resources. + */ + staticResource: boolean; + /** + * List of IDs that correlate to the Bot Management heuristic detections made on a request (you can have multiple heuristic detections on the same request). + */ + detectionIds: number[]; +} +interface IncomingRequestCfPropertiesBotManagement { + /** + * Results of Cloudflare's Bot Management analysis + */ + botManagement: IncomingRequestCfPropertiesBotManagementBase; + /** + * Duplicate of `botManagement.score`. + * + * @deprecated + */ + clientTrustScore: number; +} +interface IncomingRequestCfPropertiesBotManagementEnterprise extends IncomingRequestCfPropertiesBotManagement { + /** + * Results of Cloudflare's Bot Management analysis + */ + botManagement: IncomingRequestCfPropertiesBotManagementBase & { + /** + * A [JA3 Fingerprint](https://developers.cloudflare.com/bots/concepts/ja3-fingerprint/) to help profile specific SSL/TLS clients + * across different destination IPs, Ports, and X509 certificates. + */ + ja3Hash: string; + }; +} +interface IncomingRequestCfPropertiesCloudflareForSaaSEnterprise { + /** + * Custom metadata set per-host in [Cloudflare for SaaS](https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/). + * + * This field is only present if you have Cloudflare for SaaS enabled on your account + * and you have followed the [required steps to enable it]((https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/domain-support/custom-metadata/)). + */ + hostMetadata: HostMetadata; +} +interface IncomingRequestCfPropertiesCloudflareAccessOrApiShield { + /** + * Information about the client certificate presented to Cloudflare. + * + * This is populated when the incoming request is served over TLS using + * either Cloudflare Access or API Shield (mTLS) + * and the presented SSL certificate has a valid + * [Certificate Serial Number](https://ldapwiki.com/wiki/Certificate%20Serial%20Number) + * (i.e., not `null` or `""`). + * + * Otherwise, a set of placeholder values are used. + * + * The property `certPresented` will be set to `"1"` when + * the object is populated (i.e. the above conditions were met). + */ + tlsClientAuth: IncomingRequestCfPropertiesTLSClientAuth | IncomingRequestCfPropertiesTLSClientAuthPlaceholder; +} +/** + * Metadata about the request's TLS handshake + */ +interface IncomingRequestCfPropertiesExportedAuthenticatorMetadata { + /** + * The client's [`HELLO` message](https://www.rfc-editor.org/rfc/rfc5246#section-7.4.1.2), encoded in hexadecimal + * + * @example "44372ba35fa1270921d318f34c12f155dc87b682cf36a790cfaa3ba8737a1b5d" + */ + clientHandshake: string; + /** + * The server's [`HELLO` message](https://www.rfc-editor.org/rfc/rfc5246#section-7.4.1.2), encoded in hexadecimal + * + * @example "44372ba35fa1270921d318f34c12f155dc87b682cf36a790cfaa3ba8737a1b5d" + */ + serverHandshake: string; + /** + * The client's [`FINISHED` message](https://www.rfc-editor.org/rfc/rfc5246#section-7.4.9), encoded in hexadecimal + * + * @example "084ee802fe1348f688220e2a6040a05b2199a761f33cf753abb1b006792d3f8b" + */ + clientFinished: string; + /** + * The server's [`FINISHED` message](https://www.rfc-editor.org/rfc/rfc5246#section-7.4.9), encoded in hexadecimal + * + * @example "084ee802fe1348f688220e2a6040a05b2199a761f33cf753abb1b006792d3f8b" + */ + serverFinished: string; +} +/** + * Geographic data about the request's origin. + */ +interface IncomingRequestCfPropertiesGeographicInformation { + /** + * The [ISO 3166-1 Alpha 2](https://www.iso.org/iso-3166-country-codes.html) country code the request originated from. + * + * If your worker is [configured to accept TOR connections](https://support.cloudflare.com/hc/en-us/articles/203306930-Understanding-Cloudflare-Tor-support-and-Onion-Routing), this may also be `"T1"`, indicating a request that originated over TOR. + * + * If Cloudflare is unable to determine where the request originated this property is omitted. + * + * The country code `"T1"` is used for requests originating on TOR. + * + * @example "GB" + */ + country?: Iso3166Alpha2Code | "T1"; + /** + * If present, this property indicates that the request originated in the EU + * + * @example "1" + */ + isEUCountry?: "1"; + /** + * A two-letter code indicating the continent the request originated from. + * + * @example "AN" + */ + continent?: ContinentCode; + /** + * The city the request originated from + * + * @example "Austin" + */ + city?: string; + /** + * Postal code of the incoming request + * + * @example "78701" + */ + postalCode?: string; + /** + * Latitude of the incoming request + * + * @example "30.27130" + */ + latitude?: string; + /** + * Longitude of the incoming request + * + * @example "-97.74260" + */ + longitude?: string; + /** + * Timezone of the incoming request + * + * @example "America/Chicago" + */ + timezone?: string; + /** + * If known, the ISO 3166-2 name for the first level region associated with + * the IP address of the incoming request + * + * @example "Texas" + */ + region?: string; + /** + * If known, the ISO 3166-2 code for the first-level region associated with + * the IP address of the incoming request + * + * @example "TX" + */ + regionCode?: string; + /** + * Metro code (DMA) of the incoming request + * + * @example "635" + */ + metroCode?: string; +} +/** Data about the incoming request's TLS certificate */ +interface IncomingRequestCfPropertiesTLSClientAuth { + /** Always `"1"`, indicating that the certificate was presented */ + certPresented: "1"; + /** + * Result of certificate verification. + * + * @example "FAILED:self signed certificate" + */ + certVerified: Exclude; + /** The presented certificate's revokation status. + * + * - A value of `"1"` indicates the certificate has been revoked + * - A value of `"0"` indicates the certificate has not been revoked + */ + certRevoked: "1" | "0"; + /** + * The certificate issuer's [distinguished name](https://knowledge.digicert.com/generalinformation/INFO1745.html) + * + * @example "CN=cloudflareaccess.com, C=US, ST=Texas, L=Austin, O=Cloudflare" + */ + certIssuerDN: string; + /** + * The certificate subject's [distinguished name](https://knowledge.digicert.com/generalinformation/INFO1745.html) + * + * @example "CN=*.cloudflareaccess.com, C=US, ST=Texas, L=Austin, O=Cloudflare" + */ + certSubjectDN: string; + /** + * The certificate issuer's [distinguished name](https://knowledge.digicert.com/generalinformation/INFO1745.html) ([RFC 2253](https://www.rfc-editor.org/rfc/rfc2253.html) formatted) + * + * @example "CN=cloudflareaccess.com, C=US, ST=Texas, L=Austin, O=Cloudflare" + */ + certIssuerDNRFC2253: string; + /** + * The certificate subject's [distinguished name](https://knowledge.digicert.com/generalinformation/INFO1745.html) ([RFC 2253](https://www.rfc-editor.org/rfc/rfc2253.html) formatted) + * + * @example "CN=*.cloudflareaccess.com, C=US, ST=Texas, L=Austin, O=Cloudflare" + */ + certSubjectDNRFC2253: string; + /** The certificate issuer's distinguished name (legacy policies) */ + certIssuerDNLegacy: string; + /** The certificate subject's distinguished name (legacy policies) */ + certSubjectDNLegacy: string; + /** + * The certificate's serial number + * + * @example "00936EACBE07F201DF" + */ + certSerial: string; + /** + * The certificate issuer's serial number + * + * @example "2489002934BDFEA34" + */ + certIssuerSerial: string; + /** + * The certificate's Subject Key Identifier + * + * @example "BB:AF:7E:02:3D:FA:A6:F1:3C:84:8E:AD:EE:38:98:EC:D9:32:32:D4" + */ + certSKI: string; + /** + * The certificate issuer's Subject Key Identifier + * + * @example "BB:AF:7E:02:3D:FA:A6:F1:3C:84:8E:AD:EE:38:98:EC:D9:32:32:D4" + */ + certIssuerSKI: string; + /** + * The certificate's SHA-1 fingerprint + * + * @example "6b9109f323999e52259cda7373ff0b4d26bd232e" + */ + certFingerprintSHA1: string; + /** + * The certificate's SHA-256 fingerprint + * + * @example "acf77cf37b4156a2708e34c4eb755f9b5dbbe5ebb55adfec8f11493438d19e6ad3f157f81fa3b98278453d5652b0c1fd1d71e5695ae4d709803a4d3f39de9dea" + */ + certFingerprintSHA256: string; + /** + * The effective starting date of the certificate + * + * @example "Dec 22 19:39:00 2018 GMT" + */ + certNotBefore: string; + /** + * The effective expiration date of the certificate + * + * @example "Dec 22 19:39:00 2018 GMT" + */ + certNotAfter: string; +} +/** Placeholder values for TLS Client Authorization */ +interface IncomingRequestCfPropertiesTLSClientAuthPlaceholder { + certPresented: "0"; + certVerified: "NONE"; + certRevoked: "0"; + certIssuerDN: ""; + certSubjectDN: ""; + certIssuerDNRFC2253: ""; + certSubjectDNRFC2253: ""; + certIssuerDNLegacy: ""; + certSubjectDNLegacy: ""; + certSerial: ""; + certIssuerSerial: ""; + certSKI: ""; + certIssuerSKI: ""; + certFingerprintSHA1: ""; + certFingerprintSHA256: ""; + certNotBefore: ""; + certNotAfter: ""; +} +/** Possible outcomes of TLS verification */ +declare type CertVerificationStatus = +/** Authentication succeeded */ +"SUCCESS" +/** No certificate was presented */ + | "NONE" +/** Failed because the certificate was self-signed */ + | "FAILED:self signed certificate" +/** Failed because the certificate failed a trust chain check */ + | "FAILED:unable to verify the first certificate" +/** Failed because the certificate not yet valid */ + | "FAILED:certificate is not yet valid" +/** Failed because the certificate is expired */ + | "FAILED:certificate has expired" +/** Failed for another unspecified reason */ + | "FAILED"; +/** + * An upstream endpoint's response to a TCP `keepalive` message from Cloudflare. + */ +declare type IncomingRequestCfPropertiesEdgeRequestKeepAliveStatus = 0 /** Unknown */ | 1 /** no keepalives (not found) */ | 2 /** no connection re-use, opening keepalive connection failed */ | 3 /** no connection re-use, keepalive accepted and saved */ | 4 /** connection re-use, refused by the origin server (`TCP FIN`) */ | 5; /** connection re-use, accepted by the origin server */ +/** ISO 3166-1 Alpha-2 codes */ +declare type Iso3166Alpha2Code = "AD" | "AE" | "AF" | "AG" | "AI" | "AL" | "AM" | "AO" | "AQ" | "AR" | "AS" | "AT" | "AU" | "AW" | "AX" | "AZ" | "BA" | "BB" | "BD" | "BE" | "BF" | "BG" | "BH" | "BI" | "BJ" | "BL" | "BM" | "BN" | "BO" | "BQ" | "BR" | "BS" | "BT" | "BV" | "BW" | "BY" | "BZ" | "CA" | "CC" | "CD" | "CF" | "CG" | "CH" | "CI" | "CK" | "CL" | "CM" | "CN" | "CO" | "CR" | "CU" | "CV" | "CW" | "CX" | "CY" | "CZ" | "DE" | "DJ" | "DK" | "DM" | "DO" | "DZ" | "EC" | "EE" | "EG" | "EH" | "ER" | "ES" | "ET" | "FI" | "FJ" | "FK" | "FM" | "FO" | "FR" | "GA" | "GB" | "GD" | "GE" | "GF" | "GG" | "GH" | "GI" | "GL" | "GM" | "GN" | "GP" | "GQ" | "GR" | "GS" | "GT" | "GU" | "GW" | "GY" | "HK" | "HM" | "HN" | "HR" | "HT" | "HU" | "ID" | "IE" | "IL" | "IM" | "IN" | "IO" | "IQ" | "IR" | "IS" | "IT" | "JE" | "JM" | "JO" | "JP" | "KE" | "KG" | "KH" | "KI" | "KM" | "KN" | "KP" | "KR" | "KW" | "KY" | "KZ" | "LA" | "LB" | "LC" | "LI" | "LK" | "LR" | "LS" | "LT" | "LU" | "LV" | "LY" | "MA" | "MC" | "MD" | "ME" | "MF" | "MG" | "MH" | "MK" | "ML" | "MM" | "MN" | "MO" | "MP" | "MQ" | "MR" | "MS" | "MT" | "MU" | "MV" | "MW" | "MX" | "MY" | "MZ" | "NA" | "NC" | "NE" | "NF" | "NG" | "NI" | "NL" | "NO" | "NP" | "NR" | "NU" | "NZ" | "OM" | "PA" | "PE" | "PF" | "PG" | "PH" | "PK" | "PL" | "PM" | "PN" | "PR" | "PS" | "PT" | "PW" | "PY" | "QA" | "RE" | "RO" | "RS" | "RU" | "RW" | "SA" | "SB" | "SC" | "SD" | "SE" | "SG" | "SH" | "SI" | "SJ" | "SK" | "SL" | "SM" | "SN" | "SO" | "SR" | "SS" | "ST" | "SV" | "SX" | "SY" | "SZ" | "TC" | "TD" | "TF" | "TG" | "TH" | "TJ" | "TK" | "TL" | "TM" | "TN" | "TO" | "TR" | "TT" | "TV" | "TW" | "TZ" | "UA" | "UG" | "UM" | "US" | "UY" | "UZ" | "VA" | "VC" | "VE" | "VG" | "VI" | "VN" | "VU" | "WF" | "WS" | "YE" | "YT" | "ZA" | "ZM" | "ZW"; +/** The 2-letter continent codes Cloudflare uses */ +declare type ContinentCode = "AF" | "AN" | "AS" | "EU" | "NA" | "OC" | "SA"; +type CfProperties = IncomingRequestCfProperties | RequestInitCfProperties; +interface D1Meta { + duration: number; + size_after: number; + rows_read: number; + rows_written: number; + last_row_id: number; + changed_db: boolean; + changes: number; + /** + * The region of the database instance that executed the query. + */ + served_by_region?: string; + /** + * True if-and-only-if the database instance that executed the query was the primary. + */ + served_by_primary?: boolean; + timings?: { + /** + * The duration of the SQL query execution by the database instance. It doesn't include any network time. + */ + sql_duration_ms: number; + }; +} +interface D1Response { + success: true; + meta: D1Meta & Record; + error?: never; +} +type D1Result = D1Response & { + results: T[]; +}; +interface D1ExecResult { + count: number; + duration: number; +} +type D1SessionConstraint = +// Indicates that the first query should go to the primary, and the rest queries +// using the same D1DatabaseSession will go to any replica that is consistent with +// the bookmark maintained by the session (returned by the first query). +"first-primary" +// Indicates that the first query can go anywhere (primary or replica), and the rest queries +// using the same D1DatabaseSession will go to any replica that is consistent with +// the bookmark maintained by the session (returned by the first query). + | "first-unconstrained"; +type D1SessionBookmark = string; +declare abstract class D1Database { + prepare(query: string): D1PreparedStatement; + batch(statements: D1PreparedStatement[]): Promise[]>; + exec(query: string): Promise; + /** + * Creates a new D1 Session anchored at the given constraint or the bookmark. + * All queries executed using the created session will have sequential consistency, + * meaning that all writes done through the session will be visible in subsequent reads. + * + * @param constraintOrBookmark Either the session constraint or the explicit bookmark to anchor the created session. + */ + withSession(constraintOrBookmark?: D1SessionBookmark | D1SessionConstraint): D1DatabaseSession; + /** + * @deprecated dump() will be removed soon, only applies to deprecated alpha v1 databases. + */ + dump(): Promise; +} +declare abstract class D1DatabaseSession { + prepare(query: string): D1PreparedStatement; + batch(statements: D1PreparedStatement[]): Promise[]>; + /** + * @returns The latest session bookmark across all executed queries on the session. + * If no query has been executed yet, `null` is returned. + */ + getBookmark(): D1SessionBookmark | null; +} +declare abstract class D1PreparedStatement { + bind(...values: unknown[]): D1PreparedStatement; + first(colName: string): Promise; + first>(): Promise; + run>(): Promise>; + all>(): Promise>; + raw(options: { + columnNames: true; + }): Promise<[ + string[], + ...T[] + ]>; + raw(options?: { + columnNames?: false; + }): Promise; +} +// `Disposable` was added to TypeScript's standard lib types in version 5.2. +// To support older TypeScript versions, define an empty `Disposable` interface. +// Users won't be able to use `using`/`Symbol.dispose` without upgrading to 5.2, +// but this will ensure type checking on older versions still passes. +// TypeScript's interface merging will ensure our empty interface is effectively +// ignored when `Disposable` is included in the standard lib. +interface Disposable { +} +/** + * An email message that can be sent from a Worker. + */ +interface EmailMessage { + /** + * Envelope From attribute of the email message. + */ + readonly from: string; + /** + * Envelope To attribute of the email message. + */ + readonly to: string; +} +/** + * An email message that is sent to a consumer Worker and can be rejected/forwarded. + */ +interface ForwardableEmailMessage extends EmailMessage { + /** + * Stream of the email message content. + */ + readonly raw: ReadableStream; + /** + * An [Headers object](https://developer.mozilla.org/en-US/docs/Web/API/Headers). + */ + readonly headers: Headers; + /** + * Size of the email message content. + */ + readonly rawSize: number; + /** + * Reject this email message by returning a permanent SMTP error back to the connecting client including the given reason. + * @param reason The reject reason. + * @returns void + */ + setReject(reason: string): void; + /** + * Forward this email message to a verified destination address of the account. + * @param rcptTo Verified destination address. + * @param headers A [Headers object](https://developer.mozilla.org/en-US/docs/Web/API/Headers). + * @returns A promise that resolves when the email message is forwarded. + */ + forward(rcptTo: string, headers?: Headers): Promise; + /** + * Reply to the sender of this email message with a new EmailMessage object. + * @param message The reply message. + * @returns A promise that resolves when the email message is replied. + */ + reply(message: EmailMessage): Promise; +} +/** + * A binding that allows a Worker to send email messages. + */ +interface SendEmail { + send(message: EmailMessage): Promise; +} +declare abstract class EmailEvent extends ExtendableEvent { + readonly message: ForwardableEmailMessage; +} +declare type EmailExportedHandler = (message: ForwardableEmailMessage, env: Env, ctx: ExecutionContext) => void | Promise; +declare module "cloudflare:email" { + let _EmailMessage: { + prototype: EmailMessage; + new (from: string, to: string, raw: ReadableStream | string): EmailMessage; + }; + export { _EmailMessage as EmailMessage }; +} +/** + * Hello World binding to serve as an explanatory example. DO NOT USE + */ +interface HelloWorldBinding { + /** + * Retrieve the current stored value + */ + get(): Promise<{ + value: string; + ms?: number; + }>; + /** + * Set a new stored value + */ + set(value: string): Promise; +} +interface Hyperdrive { + /** + * Connect directly to Hyperdrive as if it's your database, returning a TCP socket. + * + * Calling this method returns an idential socket to if you call + * `connect("host:port")` using the `host` and `port` fields from this object. + * Pick whichever approach works better with your preferred DB client library. + * + * Note that this socket is not yet authenticated -- it's expected that your + * code (or preferably, the client library of your choice) will authenticate + * using the information in this class's readonly fields. + */ + connect(): Socket; + /** + * A valid DB connection string that can be passed straight into the typical + * client library/driver/ORM. This will typically be the easiest way to use + * Hyperdrive. + */ + readonly connectionString: string; + /* + * A randomly generated hostname that is only valid within the context of the + * currently running Worker which, when passed into `connect()` function from + * the "cloudflare:sockets" module, will connect to the Hyperdrive instance + * for your database. + */ + readonly host: string; + /* + * The port that must be paired the the host field when connecting. + */ + readonly port: number; + /* + * The username to use when authenticating to your database via Hyperdrive. + * Unlike the host and password, this will be the same every time + */ + readonly user: string; + /* + * The randomly generated password to use when authenticating to your + * database via Hyperdrive. Like the host field, this password is only valid + * within the context of the currently running Worker instance from which + * it's read. + */ + readonly password: string; + /* + * The name of the database to connect to. + */ + readonly database: string; +} +// Copyright (c) 2024 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +type ImageInfoResponse = { + format: 'image/svg+xml'; +} | { + format: string; + fileSize: number; + width: number; + height: number; +}; +type ImageTransform = { + width?: number; + height?: number; + background?: string; + blur?: number; + border?: { + color?: string; + width?: number; + } | { + top?: number; + bottom?: number; + left?: number; + right?: number; + }; + brightness?: number; + contrast?: number; + fit?: 'scale-down' | 'contain' | 'pad' | 'squeeze' | 'cover' | 'crop'; + flip?: 'h' | 'v' | 'hv'; + gamma?: number; + gravity?: 'left' | 'right' | 'top' | 'bottom' | 'center' | 'auto' | 'entropy' | { + x?: number; + y?: number; + mode: 'remainder' | 'box-center'; + }; + rotate?: 0 | 90 | 180 | 270; + saturation?: number; + sharpen?: number; + trim?: "border" | { + top?: number; + bottom?: number; + left?: number; + right?: number; + width?: number; + height?: number; + border?: boolean | { + color?: string; + tolerance?: number; + keep?: number; + }; + }; +}; +type ImageDrawOptions = { + opacity?: number; + repeat?: boolean | string; + top?: number; + left?: number; + bottom?: number; + right?: number; +}; +type ImageOutputOptions = { + format: 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp' | 'image/avif' | 'rgb' | 'rgba'; + quality?: number; + background?: string; +}; +interface ImagesBinding { + /** + * Get image metadata (type, width and height) + * @throws {@link ImagesError} with code 9412 if input is not an image + * @param stream The image bytes + */ + info(stream: ReadableStream): Promise; + /** + * Begin applying a series of transformations to an image + * @param stream The image bytes + * @returns A transform handle + */ + input(stream: ReadableStream): ImageTransformer; +} +interface ImageTransformer { + /** + * Apply transform next, returning a transform handle. + * You can then apply more transformations, draw, or retrieve the output. + * @param transform + */ + transform(transform: ImageTransform): ImageTransformer; + /** + * Draw an image on this transformer, returning a transform handle. + * You can then apply more transformations, draw, or retrieve the output. + * @param image The image (or transformer that will give the image) to draw + * @param options The options configuring how to draw the image + */ + draw(image: ReadableStream | ImageTransformer, options?: ImageDrawOptions): ImageTransformer; + /** + * Retrieve the image that results from applying the transforms to the + * provided input + * @param options Options that apply to the output e.g. output format + */ + output(options: ImageOutputOptions): Promise; +} +interface ImageTransformationResult { + /** + * The image as a response, ready to store in cache or return to users + */ + response(): Response; + /** + * The content type of the returned image + */ + contentType(): string; + /** + * The bytes of the response + */ + image(): ReadableStream; +} +interface ImagesError extends Error { + readonly code: number; + readonly message: string; + readonly stack?: string; +} +type Params

= Record; +type EventContext = { + request: Request>; + functionPath: string; + waitUntil: (promise: Promise) => void; + passThroughOnException: () => void; + next: (input?: Request | string, init?: RequestInit) => Promise; + env: Env & { + ASSETS: { + fetch: typeof fetch; + }; + }; + params: Params

; + data: Data; +}; +type PagesFunction = Record> = (context: EventContext) => Response | Promise; +type EventPluginContext = { + request: Request>; + functionPath: string; + waitUntil: (promise: Promise) => void; + passThroughOnException: () => void; + next: (input?: Request | string, init?: RequestInit) => Promise; + env: Env & { + ASSETS: { + fetch: typeof fetch; + }; + }; + params: Params

) => Result> : Result>; + // Type for the callable part of an `Provider` if `T` is callable. + // This is intersected with methods/properties. + type MaybeCallableProvider = T extends (...args: any[]) => any ? MethodOrProperty : unknown; + // Base type for all other types providing RPC-like interfaces. + // Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types. + // `Reserved` names (e.g. stub method names like `dup()`) and symbols can't be accessed over RPC. + export type Provider = MaybeCallableProvider & { + [K in Exclude>]: MethodOrProperty; + }; +} +declare namespace Cloudflare { + interface Env { + } +} +declare module 'cloudflare:workers' { + export type RpcStub = Rpc.Stub; + export const RpcStub: { + new (value: T): Rpc.Stub; + }; + export abstract class RpcTarget implements Rpc.RpcTargetBranded { + [Rpc.__RPC_TARGET_BRAND]: never; + } + // `protected` fields don't appear in `keyof`s, so can't be accessed over RPC + export abstract class WorkerEntrypoint implements Rpc.WorkerEntrypointBranded { + [Rpc.__WORKER_ENTRYPOINT_BRAND]: never; + protected ctx: ExecutionContext; + protected env: Env; + constructor(ctx: ExecutionContext, env: Env); + fetch?(request: Request): Response | Promise; + tail?(events: TraceItem[]): void | Promise; + trace?(traces: TraceItem[]): void | Promise; + scheduled?(controller: ScheduledController): void | Promise; + queue?(batch: MessageBatch): void | Promise; + test?(controller: TestController): void | Promise; + } + export abstract class DurableObject implements Rpc.DurableObjectBranded { + [Rpc.__DURABLE_OBJECT_BRAND]: never; + protected ctx: DurableObjectState; + protected env: Env; + constructor(ctx: DurableObjectState, env: Env); + fetch?(request: Request): Response | Promise; + alarm?(alarmInfo?: AlarmInvocationInfo): void | Promise; + webSocketMessage?(ws: WebSocket, message: string | ArrayBuffer): void | Promise; + webSocketClose?(ws: WebSocket, code: number, reason: string, wasClean: boolean): void | Promise; + webSocketError?(ws: WebSocket, error: unknown): void | Promise; + } + export type WorkflowDurationLabel = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year'; + export type WorkflowSleepDuration = `${number} ${WorkflowDurationLabel}${'s' | ''}` | number; + export type WorkflowDelayDuration = WorkflowSleepDuration; + export type WorkflowTimeoutDuration = WorkflowSleepDuration; + export type WorkflowRetentionDuration = WorkflowSleepDuration; + export type WorkflowBackoff = 'constant' | 'linear' | 'exponential'; + export type WorkflowStepConfig = { + retries?: { + limit: number; + delay: WorkflowDelayDuration | number; + backoff?: WorkflowBackoff; + }; + timeout?: WorkflowTimeoutDuration | number; + }; + export type WorkflowEvent = { + payload: Readonly; + timestamp: Date; + instanceId: string; + }; + export type WorkflowStepEvent = { + payload: Readonly; + timestamp: Date; + type: string; + }; + export abstract class WorkflowStep { + do>(name: string, callback: () => Promise): Promise; + do>(name: string, config: WorkflowStepConfig, callback: () => Promise): Promise; + sleep: (name: string, duration: WorkflowSleepDuration) => Promise; + sleepUntil: (name: string, timestamp: Date | number) => Promise; + waitForEvent>(name: string, options: { + type: string; + timeout?: WorkflowTimeoutDuration | number; + }): Promise>; + } + export abstract class WorkflowEntrypoint | unknown = unknown> implements Rpc.WorkflowEntrypointBranded { + [Rpc.__WORKFLOW_ENTRYPOINT_BRAND]: never; + protected ctx: ExecutionContext; + protected env: Env; + constructor(ctx: ExecutionContext, env: Env); + run(event: Readonly>, step: WorkflowStep): Promise; + } + export const env: Cloudflare.Env; +} +interface SecretsStoreSecret { + /** + * Get a secret from the Secrets Store, returning a string of the secret value + * if it exists, or throws an error if it does not exist + */ + get(): Promise; +} +declare module "cloudflare:sockets" { + function _connect(address: string | SocketAddress, options?: SocketOptions): Socket; + export { _connect as connect }; +} +declare namespace TailStream { + interface Header { + readonly name: string; + readonly value: string; + } + interface FetchEventInfo { + readonly type: "fetch"; + readonly method: string; + readonly url: string; + readonly cfJson: string; + readonly headers: Header[]; + } + interface JsRpcEventInfo { + readonly type: "jsrpc"; + readonly methodName: string; + } + interface ScheduledEventInfo { + readonly type: "scheduled"; + readonly scheduledTime: Date; + readonly cron: string; + } + interface AlarmEventInfo { + readonly type: "alarm"; + readonly scheduledTime: Date; + } + interface QueueEventInfo { + readonly type: "queue"; + readonly queueName: string; + readonly batchSize: number; + } + interface EmailEventInfo { + readonly type: "email"; + readonly mailFrom: string; + readonly rcptTo: string; + readonly rawSize: number; + } + interface TraceEventInfo { + readonly type: "trace"; + readonly traces: (string | null)[]; + } + interface HibernatableWebSocketEventInfoMessage { + readonly type: "message"; + } + interface HibernatableWebSocketEventInfoError { + readonly type: "error"; + } + interface HibernatableWebSocketEventInfoClose { + readonly type: "close"; + readonly code: number; + readonly wasClean: boolean; + } + interface HibernatableWebSocketEventInfo { + readonly type: "hibernatableWebSocket"; + readonly info: HibernatableWebSocketEventInfoClose | HibernatableWebSocketEventInfoError | HibernatableWebSocketEventInfoMessage; + } + interface Resume { + readonly type: "resume"; + readonly attachment?: any; + } + interface CustomEventInfo { + readonly type: "custom"; + } + interface FetchResponseInfo { + readonly type: "fetch"; + readonly statusCode: number; + } + type EventOutcome = "ok" | "canceled" | "exception" | "unknown" | "killSwitch" | "daemonDown" | "exceededCpu" | "exceededMemory" | "loadShed" | "responseStreamDisconnected" | "scriptNotFound"; + interface ScriptVersion { + readonly id: string; + readonly tag?: string; + readonly message?: string; + } + interface Trigger { + readonly traceId: string; + readonly invocationId: string; + readonly spanId: string; + } + interface Onset { + readonly type: "onset"; + readonly dispatchNamespace?: string; + readonly entrypoint?: string; + readonly executionModel: string; + readonly scriptName?: string; + readonly scriptTags?: string[]; + readonly scriptVersion?: ScriptVersion; + readonly trigger?: Trigger; + readonly info: FetchEventInfo | JsRpcEventInfo | ScheduledEventInfo | AlarmEventInfo | QueueEventInfo | EmailEventInfo | TraceEventInfo | HibernatableWebSocketEventInfo | Resume | CustomEventInfo; + } + interface Outcome { + readonly type: "outcome"; + readonly outcome: EventOutcome; + readonly cpuTime: number; + readonly wallTime: number; + } + interface Hibernate { + readonly type: "hibernate"; + } + interface SpanOpen { + readonly type: "spanOpen"; + readonly name: string; + readonly info?: FetchEventInfo | JsRpcEventInfo | Attributes; + } + interface SpanClose { + readonly type: "spanClose"; + readonly outcome: EventOutcome; + } + interface DiagnosticChannelEvent { + readonly type: "diagnosticChannel"; + readonly channel: string; + readonly message: any; + } + interface Exception { + readonly type: "exception"; + readonly name: string; + readonly message: string; + readonly stack?: string; + } + interface Log { + readonly type: "log"; + readonly level: "debug" | "error" | "info" | "log" | "warn"; + readonly message: string; + } + interface Return { + readonly type: "return"; + readonly info?: FetchResponseInfo; + } + interface Link { + readonly type: "link"; + readonly label?: string; + readonly traceId: string; + readonly invocationId: string; + readonly spanId: string; + } + interface Attribute { + readonly name: string; + readonly value: string | string[] | boolean | boolean[] | number | number[] | bigint | bigint[]; + } + interface Attributes { + readonly type: "attributes"; + readonly info: Attribute[]; + } + type EventType = Onset | Outcome | Hibernate | SpanOpen | SpanClose | DiagnosticChannelEvent | Exception | Log | Return | Link | Attributes; + interface TailEvent { + readonly invocationId: string; + readonly spanId: string; + readonly timestamp: Date; + readonly sequence: number; + readonly event: Event; + } + type TailEventHandler = (event: TailEvent) => void | Promise; + type TailEventHandlerObject = { + outcome?: TailEventHandler; + hibernate?: TailEventHandler; + spanOpen?: TailEventHandler; + spanClose?: TailEventHandler; + diagnosticChannel?: TailEventHandler; + exception?: TailEventHandler; + log?: TailEventHandler; + return?: TailEventHandler; + link?: TailEventHandler; + attributes?: TailEventHandler; + }; + type TailEventHandlerType = TailEventHandler | TailEventHandlerObject; +} +// Copyright (c) 2022-2023 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +/** + * Data types supported for holding vector metadata. + */ +type VectorizeVectorMetadataValue = string | number | boolean | string[]; +/** + * Additional information to associate with a vector. + */ +type VectorizeVectorMetadata = VectorizeVectorMetadataValue | Record; +type VectorFloatArray = Float32Array | Float64Array; +interface VectorizeError { + code?: number; + error: string; +} +/** + * Comparison logic/operation to use for metadata filtering. + * + * This list is expected to grow as support for more operations are released. + */ +type VectorizeVectorMetadataFilterOp = "$eq" | "$ne"; +/** + * Filter criteria for vector metadata used to limit the retrieved query result set. + */ +type VectorizeVectorMetadataFilter = { + [field: string]: Exclude | null | { + [Op in VectorizeVectorMetadataFilterOp]?: Exclude | null; + }; +}; +/** + * Supported distance metrics for an index. + * Distance metrics determine how other "similar" vectors are determined. + */ +type VectorizeDistanceMetric = "euclidean" | "cosine" | "dot-product"; +/** + * Metadata return levels for a Vectorize query. + * + * Default to "none". + * + * @property all Full metadata for the vector return set, including all fields (including those un-indexed) without truncation. This is a more expensive retrieval, as it requires additional fetching & reading of un-indexed data. + * @property indexed Return all metadata fields configured for indexing in the vector return set. This level of retrieval is "free" in that no additional overhead is incurred returning this data. However, note that indexed metadata is subject to truncation (especially for larger strings). + * @property none No indexed metadata will be returned. + */ +type VectorizeMetadataRetrievalLevel = "all" | "indexed" | "none"; +interface VectorizeQueryOptions { + topK?: number; + namespace?: string; + returnValues?: boolean; + returnMetadata?: boolean | VectorizeMetadataRetrievalLevel; + filter?: VectorizeVectorMetadataFilter; +} +/** + * Information about the configuration of an index. + */ +type VectorizeIndexConfig = { + dimensions: number; + metric: VectorizeDistanceMetric; +} | { + preset: string; // keep this generic, as we'll be adding more presets in the future and this is only in a read capacity +}; +/** + * Metadata about an existing index. + * + * This type is exclusively for the Vectorize **beta** and will be deprecated once Vectorize RC is released. + * See {@link VectorizeIndexInfo} for its post-beta equivalent. + */ +interface VectorizeIndexDetails { + /** The unique ID of the index */ + readonly id: string; + /** The name of the index. */ + name: string; + /** (optional) A human readable description for the index. */ + description?: string; + /** The index configuration, including the dimension size and distance metric. */ + config: VectorizeIndexConfig; + /** The number of records containing vectors within the index. */ + vectorsCount: number; +} +/** + * Metadata about an existing index. + */ +interface VectorizeIndexInfo { + /** The number of records containing vectors within the index. */ + vectorCount: number; + /** Number of dimensions the index has been configured for. */ + dimensions: number; + /** ISO 8601 datetime of the last processed mutation on in the index. All changes before this mutation will be reflected in the index state. */ + processedUpToDatetime: number; + /** UUIDv4 of the last mutation processed by the index. All changes before this mutation will be reflected in the index state. */ + processedUpToMutation: number; +} +/** + * Represents a single vector value set along with its associated metadata. + */ +interface VectorizeVector { + /** The ID for the vector. This can be user-defined, and must be unique. It should uniquely identify the object, and is best set based on the ID of what the vector represents. */ + id: string; + /** The vector values */ + values: VectorFloatArray | number[]; + /** The namespace this vector belongs to. */ + namespace?: string; + /** Metadata associated with the vector. Includes the values of other fields and potentially additional details. */ + metadata?: Record; +} +/** + * Represents a matched vector for a query along with its score and (if specified) the matching vector information. + */ +type VectorizeMatch = Pick, "values"> & Omit & { + /** The score or rank for similarity, when returned as a result */ + score: number; +}; +/** + * A set of matching {@link VectorizeMatch} for a particular query. + */ +interface VectorizeMatches { + matches: VectorizeMatch[]; + count: number; +} +/** + * Results of an operation that performed a mutation on a set of vectors. + * Here, `ids` is a list of vectors that were successfully processed. + * + * This type is exclusively for the Vectorize **beta** and will be deprecated once Vectorize RC is released. + * See {@link VectorizeAsyncMutation} for its post-beta equivalent. + */ +interface VectorizeVectorMutation { + /* List of ids of vectors that were successfully processed. */ + ids: string[]; + /* Total count of the number of processed vectors. */ + count: number; +} +/** + * Result type indicating a mutation on the Vectorize Index. + * Actual mutations are processed async where the `mutationId` is the unique identifier for the operation. + */ +interface VectorizeAsyncMutation { + /** The unique identifier for the async mutation operation containing the changeset. */ + mutationId: string; +} +/** + * A Vectorize Vector Search Index for querying vectors/embeddings. + * + * This type is exclusively for the Vectorize **beta** and will be deprecated once Vectorize RC is released. + * See {@link Vectorize} for its new implementation. + */ +declare abstract class VectorizeIndex { + /** + * Get information about the currently bound index. + * @returns A promise that resolves with information about the current index. + */ + public describe(): Promise; + /** + * Use the provided vector to perform a similarity search across the index. + * @param vector Input vector that will be used to drive the similarity search. + * @param options Configuration options to massage the returned data. + * @returns A promise that resolves with matched and scored vectors. + */ + public query(vector: VectorFloatArray | number[], options?: VectorizeQueryOptions): Promise; + /** + * Insert a list of vectors into the index dataset. If a provided id exists, an error will be thrown. + * @param vectors List of vectors that will be inserted. + * @returns A promise that resolves with the ids & count of records that were successfully processed. + */ + public insert(vectors: VectorizeVector[]): Promise; + /** + * Upsert a list of vectors into the index dataset. If a provided id exists, it will be replaced with the new values. + * @param vectors List of vectors that will be upserted. + * @returns A promise that resolves with the ids & count of records that were successfully processed. + */ + public upsert(vectors: VectorizeVector[]): Promise; + /** + * Delete a list of vectors with a matching id. + * @param ids List of vector ids that should be deleted. + * @returns A promise that resolves with the ids & count of records that were successfully processed (and thus deleted). + */ + public deleteByIds(ids: string[]): Promise; + /** + * Get a list of vectors with a matching id. + * @param ids List of vector ids that should be returned. + * @returns A promise that resolves with the raw unscored vectors matching the id set. + */ + public getByIds(ids: string[]): Promise; +} +/** + * A Vectorize Vector Search Index for querying vectors/embeddings. + * + * Mutations in this version are async, returning a mutation id. + */ +declare abstract class Vectorize { + /** + * Get information about the currently bound index. + * @returns A promise that resolves with information about the current index. + */ + public describe(): Promise; + /** + * Use the provided vector to perform a similarity search across the index. + * @param vector Input vector that will be used to drive the similarity search. + * @param options Configuration options to massage the returned data. + * @returns A promise that resolves with matched and scored vectors. + */ + public query(vector: VectorFloatArray | number[], options?: VectorizeQueryOptions): Promise; + /** + * Use the provided vector-id to perform a similarity search across the index. + * @param vectorId Id for a vector in the index against which the index should be queried. + * @param options Configuration options to massage the returned data. + * @returns A promise that resolves with matched and scored vectors. + */ + public queryById(vectorId: string, options?: VectorizeQueryOptions): Promise; + /** + * Insert a list of vectors into the index dataset. If a provided id exists, an error will be thrown. + * @param vectors List of vectors that will be inserted. + * @returns A promise that resolves with a unique identifier of a mutation containing the insert changeset. + */ + public insert(vectors: VectorizeVector[]): Promise; + /** + * Upsert a list of vectors into the index dataset. If a provided id exists, it will be replaced with the new values. + * @param vectors List of vectors that will be upserted. + * @returns A promise that resolves with a unique identifier of a mutation containing the upsert changeset. + */ + public upsert(vectors: VectorizeVector[]): Promise; + /** + * Delete a list of vectors with a matching id. + * @param ids List of vector ids that should be deleted. + * @returns A promise that resolves with a unique identifier of a mutation containing the delete changeset. + */ + public deleteByIds(ids: string[]): Promise; + /** + * Get a list of vectors with a matching id. + * @param ids List of vector ids that should be returned. + * @returns A promise that resolves with the raw unscored vectors matching the id set. + */ + public getByIds(ids: string[]): Promise; +} +/** + * The interface for "version_metadata" binding + * providing metadata about the Worker Version using this binding. + */ +type WorkerVersionMetadata = { + /** The ID of the Worker Version using this binding */ + id: string; + /** The tag of the Worker Version using this binding */ + tag: string; + /** The timestamp of when the Worker Version was uploaded */ + timestamp: string; +}; +interface DynamicDispatchLimits { + /** + * Limit CPU time in milliseconds. + */ + cpuMs?: number; + /** + * Limit number of subrequests. + */ + subRequests?: number; +} +interface DynamicDispatchOptions { + /** + * Limit resources of invoked Worker script. + */ + limits?: DynamicDispatchLimits; + /** + * Arguments for outbound Worker script, if configured. + */ + outbound?: { + [key: string]: any; + }; +} +interface DispatchNamespace { + /** + * @param name Name of the Worker script. + * @param args Arguments to Worker script. + * @param options Options for Dynamic Dispatch invocation. + * @returns A Fetcher object that allows you to send requests to the Worker script. + * @throws If the Worker script does not exist in this dispatch namespace, an error will be thrown. + */ + get(name: string, args?: { + [key: string]: any; + }, options?: DynamicDispatchOptions): Fetcher; +} +declare module 'cloudflare:workflows' { + /** + * NonRetryableError allows for a user to throw a fatal error + * that makes a Workflow instance fail immediately without triggering a retry + */ + export class NonRetryableError extends Error { + public constructor(message: string, name?: string); + } +} +declare abstract class Workflow { + /** + * Get a handle to an existing instance of the Workflow. + * @param id Id for the instance of this Workflow + * @returns A promise that resolves with a handle for the Instance + */ + public get(id: string): Promise; + /** + * Create a new instance and return a handle to it. If a provided id exists, an error will be thrown. + * @param options Options when creating an instance including id and params + * @returns A promise that resolves with a handle for the Instance + */ + public create(options?: WorkflowInstanceCreateOptions): Promise; + /** + * Create a batch of instances and return handle for all of them. If a provided id exists, an error will be thrown. + * `createBatch` is limited at 100 instances at a time or when the RPC limit for the batch (1MiB) is reached. + * @param batch List of Options when creating an instance including name and params + * @returns A promise that resolves with a list of handles for the created instances. + */ + public createBatch(batch: WorkflowInstanceCreateOptions[]): Promise; +} +type WorkflowDurationLabel = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year'; +type WorkflowSleepDuration = `${number} ${WorkflowDurationLabel}${'s' | ''}` | number; +type WorkflowRetentionDuration = WorkflowSleepDuration; +interface WorkflowInstanceCreateOptions { + /** + * An id for your Workflow instance. Must be unique within the Workflow. + */ + id?: string; + /** + * The event payload the Workflow instance is triggered with + */ + params?: PARAMS; + /** + * The retention policy for Workflow instance. + * Defaults to the maximum retention period available for the owner's account. + */ + retention?: { + successRetention?: WorkflowRetentionDuration; + errorRetention?: WorkflowRetentionDuration; + }; +} +type InstanceStatus = { + status: 'queued' // means that instance is waiting to be started (see concurrency limits) + | 'running' | 'paused' | 'errored' | 'terminated' // user terminated the instance while it was running + | 'complete' | 'waiting' // instance is hibernating and waiting for sleep or event to finish + | 'waitingForPause' // instance is finishing the current work to pause + | 'unknown'; + error?: string; + output?: object; +}; +interface WorkflowError { + code?: number; + message: string; +} +declare abstract class WorkflowInstance { + public id: string; + /** + * Pause the instance. + */ + public pause(): Promise; + /** + * Resume the instance. If it is already running, an error will be thrown. + */ + public resume(): Promise; + /** + * Terminate the instance. If it is errored, terminated or complete, an error will be thrown. + */ + public terminate(): Promise; + /** + * Restart the instance. + */ + public restart(): Promise; + /** + * Returns the current status of the instance. + */ + public status(): Promise; + /** + * Send an event to this instance. + */ + public sendEvent({ type, payload, }: { + type: string; + payload: unknown; + }): Promise; +} diff --git a/mcp-worker/wrangler.toml b/mcp-worker/wrangler.toml index be310d6cb..4a8426a79 100644 --- a/mcp-worker/wrangler.toml +++ b/mcp-worker/wrangler.toml @@ -1,7 +1,7 @@ # Cloudflare Worker configuration for DevCycle MCP Server name = "devcycle-mcp-server" main = "src/index.ts" -compatibility_date = "2025-03-10" +compatibility_date = "2025-06-28" compatibility_flags = ["nodejs_compat"] # Durable Objects configuration @@ -16,7 +16,7 @@ name = "MCP_OBJECT" # KV namespace for OAuth session storage [[kv_namespaces]] binding = "OAUTH_KV" -id = "YOUR_KV_NAMESPACE_ID" # Replace with actual KV namespace ID +id = "511f2abf74904876ba3e4627154f4d86" # Environment variables [vars] From 7b6ea37b0e04feff2ba12443d01c973a75bb54cc Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Mon, 28 Jul 2025 14:59:27 -0400 Subject: [PATCH 09/31] feat: calling MCP tools working now --- mcp-worker/src/apiClient.ts | 30 +++--- mcp-worker/src/index.ts | 8 +- mcp-worker/src/types.ts | 11 +-- src/mcp/api/interface.ts | 18 +++- src/mcp/api/localApiClient.ts | 16 +++- src/mcp/api/workerApiClient.ts | 27 ++++-- src/mcp/server.ts | 3 +- src/mcp/tools/customPropertiesTools.ts | 35 ++++++- src/mcp/tools/environmentTools.ts | 35 ++++++- src/mcp/tools/featureTools.ts | 123 +++++++++++++++++++------ src/mcp/tools/index.ts | 11 ++- src/mcp/tools/projectTools.ts | 18 +++- src/mcp/tools/registry.ts | 1 + src/mcp/tools/resultsTools.ts | 20 +++- src/mcp/tools/selfTargetingTools.ts | 30 ++++-- src/mcp/tools/variableTools.ts | 33 ++++++- src/mcp/utils/api.ts | 20 +++- 17 files changed, 334 insertions(+), 105 deletions(-) diff --git a/mcp-worker/src/apiClient.ts b/mcp-worker/src/apiClient.ts index 005dab59c..c652e3587 100644 --- a/mcp-worker/src/apiClient.ts +++ b/mcp-worker/src/apiClient.ts @@ -21,7 +21,11 @@ export class WorkerApiClient implements IDevCycleApiClient { requiresProject: boolean = true, ): Promise { const authToken = this.getAuthToken() - const projectKey = requiresProject ? this.getProjectKey() : '' + const projectKey = this.getProjectKey() + + if (requiresProject && !projectKey) { + throw new Error('No project key found') + } console.log(`Worker MCP ${operationName}:`, { args, @@ -31,7 +35,7 @@ export class WorkerApiClient implements IDevCycleApiClient { }) try { - const result = await operation(authToken, projectKey) + const result = await operation(authToken, projectKey || '') console.log(`Worker MCP ${operationName} completed successfully`) return result } catch (error) { @@ -101,18 +105,10 @@ export class WorkerApiClient implements IDevCycleApiClient { /** * Get the project key from JWT claims or environment variables */ - private getProjectKey(): string { + private getProjectKey(): string | undefined { const claims = this.props.claims as DevCycleJWTClaims - // Try from JWT claims first - this allows user-specific project context - if (claims?.project_key) { - return claims.project_key - } - - throw new Error( - 'No project key found in JWT claims. ' + - 'Include project_key in JWT claims.', - ) + return claims?.project_key } /** @@ -153,10 +149,18 @@ export class WorkerApiClient implements IDevCycleApiClient { */ public getUserContext() { const claims = this.props.claims as DevCycleJWTClaims + let projectKey: string | undefined + try { + projectKey = this.getProjectKey() + } catch { + projectKey = undefined + } + console.log('User context:', claims) + return { userId: this.getUserId(), orgId: this.getOrgId(), - projectKey: this.getProjectKey(), + projectKey: projectKey, email: claims?.email, name: claims?.name, hasAccessToken: !!this.props.tokenSet?.accessToken, diff --git a/mcp-worker/src/index.ts b/mcp-worker/src/index.ts index c84a23061..8448b5393 100644 --- a/mcp-worker/src/index.ts +++ b/mcp-worker/src/index.ts @@ -71,12 +71,8 @@ export class DevCycleMCP extends McpAgent< serverInfo: { name: 'DevCycle CLI MCP Server', version: '1.0.0', - environment: - this.env.NODE_ENV || - 'production', - apiBaseUrl: - this.env.API_BASE_URL || - 'https://api.devcycle.com', + environment: this.env.NODE_ENV, + apiBaseUrl: this.env.API_BASE_URL, }, }, null, diff --git a/mcp-worker/src/types.ts b/mcp-worker/src/types.ts index bbd9850fe..b389796c2 100644 --- a/mcp-worker/src/types.ts +++ b/mcp-worker/src/types.ts @@ -10,6 +10,7 @@ export type UserProps = { /** OAuth token set for API authentication */ tokenSet: { accessToken: string + accessTokenTTL: number idToken: string refreshToken: string } @@ -51,14 +52,4 @@ export interface DevCycleJWTClaims extends JWTPayload { email?: string /** User's name */ name?: string - /** Auth0 subject identifier */ - sub?: string - /** Audience */ - aud?: string | string[] - /** Issuer */ - iss?: string - /** Expiration time */ - exp?: number - /** Issued at time */ - iat?: number } diff --git a/src/mcp/api/interface.ts b/src/mcp/api/interface.ts index e97379583..905588a9e 100644 --- a/src/mcp/api/interface.ts +++ b/src/mcp/api/interface.ts @@ -24,7 +24,10 @@ export interface IDevCycleApiClient { executeWithLogging( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, requiresProject?: boolean, ): Promise @@ -38,8 +41,15 @@ export interface IDevCycleApiClient { executeWithDashboardLink( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, - dashboardLink: (orgId: string, projectKey: string, result: T) => string, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, + dashboardLink: ( + orgId: string, + projectKey: string | undefined, + result: T, + ) => string, ): Promise<{ result: T; dashboardLink: string }> } @@ -132,6 +142,6 @@ export type ApiResult = */ export type DashboardLinkGenerator = ( orgId: string, - projectKey: string, + projectKey: string | undefined, result: T, ) => string diff --git a/src/mcp/api/localApiClient.ts b/src/mcp/api/localApiClient.ts index 49343a36c..c6170981d 100644 --- a/src/mcp/api/localApiClient.ts +++ b/src/mcp/api/localApiClient.ts @@ -59,7 +59,10 @@ export class LocalDevCycleApiClient implements IDevCycleApiClient { async executeWithLogging( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, requiresProject = true, ): Promise { return await this.apiClient.executeWithLogging( @@ -73,8 +76,15 @@ export class LocalDevCycleApiClient implements IDevCycleApiClient { async executeWithDashboardLink( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, - dashboardLink: (orgId: string, projectKey: string, result: T) => string, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, + dashboardLink: ( + orgId: string, + projectKey: string | undefined, + result: T, + ) => string, ): Promise<{ result: T; dashboardLink: string }> { return await this.apiClient.executeWithDashboardLink( operationName, diff --git a/src/mcp/api/workerApiClient.ts b/src/mcp/api/workerApiClient.ts index 2a31f0784..105570665 100644 --- a/src/mcp/api/workerApiClient.ts +++ b/src/mcp/api/workerApiClient.ts @@ -14,7 +14,10 @@ export class WorkerDevCycleApiClient implements IDevCycleApiClient { async executeWithLogging( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, requiresProject = true, ): Promise { // TODO: Implement Worker-specific logging that works in Cloudflare environment @@ -23,9 +26,10 @@ export class WorkerDevCycleApiClient implements IDevCycleApiClient { this.validateAuth(requiresProject) const authToken = this.authContext.getAuthToken() - const projectKey = requiresProject - ? this.authContext.getProjectKey() - : '' + const projectKey = + requiresProject && this.authContext.hasProject() + ? this.authContext.getProjectKey() + : undefined try { return await operation(authToken, projectKey) @@ -39,8 +43,15 @@ export class WorkerDevCycleApiClient implements IDevCycleApiClient { async executeWithDashboardLink( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, - dashboardLink: (orgId: string, projectKey: string, result: T) => string, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, + dashboardLink: ( + orgId: string, + projectKey: string | undefined, + result: T, + ) => string, ): Promise<{ result: T; dashboardLink: string }> { const result = await this.executeWithLogging( operationName, @@ -49,7 +60,9 @@ export class WorkerDevCycleApiClient implements IDevCycleApiClient { ) const organizationId = this.authContext.getOrgId() - const projectKey = this.authContext.getProjectKey() + const projectKey = this.authContext.hasProject() + ? this.authContext.getProjectKey() + : undefined const link = dashboardLink(organizationId, projectKey, result) return { diff --git a/src/mcp/server.ts b/src/mcp/server.ts index 433bc0ea0..875f74e94 100644 --- a/src/mcp/server.ts +++ b/src/mcp/server.ts @@ -6,6 +6,7 @@ import { } from '@modelcontextprotocol/sdk/types.js' import { DevCycleAuth } from './utils/auth' import { DevCycleApiClient } from './utils/api' +import { IDevCycleApiClient } from './api/interface' import Writer from '../ui/writer' import { featureToolDefinitions, @@ -43,7 +44,7 @@ const ENABLE_DVC_MCP_DEBUG = process.env.ENABLE_DVC_MCP_DEBUG === 'true' // Tool handler function type export type ToolHandler = ( args: unknown, - apiClient: DevCycleApiClient, + apiClient: IDevCycleApiClient, ) => Promise // Function to conditionally remove outputSchema from tool definitions diff --git a/src/mcp/tools/customPropertiesTools.ts b/src/mcp/tools/customPropertiesTools.ts index 43f0ab418..28d44d40d 100644 --- a/src/mcp/tools/customPropertiesTools.ts +++ b/src/mcp/tools/customPropertiesTools.ts @@ -23,8 +23,13 @@ import { ToolHandler } from '../server' // Helper function to generate custom properties dashboard links const generateCustomPropertiesDashboardLink = ( orgId: string, - projectKey: string, + projectKey: string | undefined, ): string => { + if (!projectKey) { + throw new Error( + 'Project key is required for custom properties dashboard link', + ) + } return `https://app.devcycle.com/o/${orgId}/p/${projectKey}/custom-properties` } @@ -307,7 +312,12 @@ export const customPropertiesToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'listCustomProperties', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for listing custom properties', + ) + } return await handleZodiosValidationErrors( () => fetchCustomProperties(authToken, projectKey), 'fetchCustomProperties', @@ -322,7 +332,12 @@ export const customPropertiesToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'createCustomProperty', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for creating custom properties', + ) + } return await handleZodiosValidationErrors( () => createCustomProperty( @@ -342,7 +357,12 @@ export const customPropertiesToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'updateCustomProperty', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for updating custom properties', + ) + } const { key, ...updateData } = validatedArgs return await handleZodiosValidationErrors( @@ -365,7 +385,12 @@ export const customPropertiesToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'deleteCustomProperty', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for deleting custom properties', + ) + } await handleZodiosValidationErrors( () => deleteCustomProperty( diff --git a/src/mcp/tools/environmentTools.ts b/src/mcp/tools/environmentTools.ts index 3c0cfb6b5..a9c3712d5 100644 --- a/src/mcp/tools/environmentTools.ts +++ b/src/mcp/tools/environmentTools.ts @@ -23,8 +23,13 @@ import { DevCycleApiClient } from '../utils/api' // Helper function to generate environment dashboard links const generateEnvironmentDashboardLink = ( orgId: string, - projectKey: string, + projectKey: string | undefined, ): string => { + if (!projectKey) { + throw new Error( + 'Project key is required for environment dashboard link', + ) + } return `https://app.devcycle.com/o/${orgId}/settings/p/${projectKey}/environments` } @@ -281,7 +286,12 @@ export const environmentToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'listEnvironments', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for listing environments', + ) + } return await handleZodiosValidationErrors( () => fetchEnvironments(authToken, projectKey), 'listEnvironments', @@ -296,7 +306,12 @@ export const environmentToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'getSdkKeys', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for getting SDK keys', + ) + } const environment = await handleZodiosValidationErrors( () => fetchEnvironmentByKey( @@ -330,7 +345,12 @@ export const environmentToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'createEnvironment', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for creating environments', + ) + } return await handleZodiosValidationErrors( () => createEnvironment(authToken, projectKey, validatedArgs), @@ -346,7 +366,12 @@ export const environmentToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'updateEnvironment', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for updating environments', + ) + } const { key, ...updateParams } = validatedArgs return await handleZodiosValidationErrors( () => diff --git a/src/mcp/tools/featureTools.ts b/src/mcp/tools/featureTools.ts index 2305abb51..b5d4b1ff4 100644 --- a/src/mcp/tools/featureTools.ts +++ b/src/mcp/tools/featureTools.ts @@ -48,17 +48,23 @@ import { handleZodiosValidationErrors } from '../utils/api' // Helper function to generate feature dashboard links const generateFeaturesDashboardLink = ( orgId: string, - projectKey: string, + projectKey: string | undefined, ): string => { + if (!projectKey) { + throw new Error('Project key is required for features dashboard link') + } return `https://app.devcycle.com/o/${orgId}/p/${projectKey}/features` } const generateFeatureDashboardLink = ( orgId: string, - projectKey: string, + projectKey: string | undefined, featureKey: string, page: 'overview' | 'manage-feature' | 'audit-log' = 'overview', ): string => { + if (!projectKey) { + throw new Error('Project key is required for feature dashboard link') + } return `https://app.devcycle.com/o/${orgId}/p/${projectKey}/features/${featureKey}/${page}` } @@ -827,7 +833,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'listFeatures', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } return await handleZodiosValidationErrors( () => fetchFeatures(authToken, projectKey, validatedArgs), 'listFeatures', @@ -842,7 +853,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'createFeature', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } if (validatedArgs.interactive) { throw new Error( 'Interactive mode not yet supported in MCP. Please provide explicit parameters: key, name, description, type', @@ -864,7 +880,7 @@ export const featureToolHandlers: Record = { 'createFeature', ) }, - (orgId: string, projectKey: string, result: any) => + (orgId: string, projectKey: string | undefined, result: any) => generateFeatureDashboardLink( orgId, projectKey, @@ -879,7 +895,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'updateFeature', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } const { key, ...updateData } = validatedArgs return await handleZodiosValidationErrors( @@ -887,7 +908,7 @@ export const featureToolHandlers: Record = { 'updateFeature', ) }, - (orgId: string, projectKey: string, result: any) => + (orgId: string, projectKey: string | undefined, result: any) => generateFeatureDashboardLink( orgId, projectKey, @@ -902,7 +923,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'updateFeatureStatus', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } const { key, ...statusData } = validatedArgs return await handleZodiosValidationErrors( @@ -916,7 +942,7 @@ export const featureToolHandlers: Record = { 'updateFeatureStatus', ) }, - (orgId: string, projectKey: string, result: any) => + (orgId: string, projectKey: string | undefined, result: any) => generateFeatureDashboardLink( orgId, projectKey, @@ -931,7 +957,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'deleteFeature', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } await handleZodiosValidationErrors( () => deleteFeature(authToken, projectKey, validatedArgs.key), @@ -950,7 +981,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'fetchFeatureVariations', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } return await handleZodiosValidationErrors( () => fetchVariations( @@ -961,7 +997,7 @@ export const featureToolHandlers: Record = { 'fetchVariations', ) }, - (orgId: string, projectKey: string) => + (orgId: string, projectKey: string | undefined) => generateFeatureDashboardLink( orgId, projectKey, @@ -976,7 +1012,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'createFeatureVariation', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } const { feature_key, ...variationData } = validatedArgs return await handleZodiosValidationErrors( @@ -990,7 +1031,7 @@ export const featureToolHandlers: Record = { 'createVariation', ) }, - (orgId: string, projectKey: string, result: any) => + (orgId: string, projectKey: string | undefined, result: any) => generateFeatureDashboardLink( orgId, projectKey, @@ -1005,7 +1046,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'updateFeatureVariation', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } const { feature_key, variation_key, ...variationData } = validatedArgs @@ -1021,7 +1067,7 @@ export const featureToolHandlers: Record = { 'updateVariation', ) }, - (orgId: string, projectKey: string, result: any) => + (orgId: string, projectKey: string | undefined, result: any) => generateFeatureDashboardLink( orgId, projectKey, @@ -1036,7 +1082,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'enableTargeting', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } await handleZodiosValidationErrors( () => enableTargeting( @@ -1051,7 +1102,7 @@ export const featureToolHandlers: Record = { message: `Targeting enabled for feature '${validatedArgs.feature_key}' in environment '${validatedArgs.environment_key}'`, } }, - (orgId: string, projectKey: string) => + (orgId: string, projectKey: string | undefined) => generateFeatureDashboardLink( orgId, projectKey, @@ -1066,7 +1117,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'disableTargeting', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } await handleZodiosValidationErrors( () => disableTargeting( @@ -1081,7 +1137,7 @@ export const featureToolHandlers: Record = { message: `Targeting disabled for feature '${validatedArgs.feature_key}' in environment '${validatedArgs.environment_key}'`, } }, - (orgId: string, projectKey: string) => + (orgId: string, projectKey: string | undefined) => generateFeatureDashboardLink( orgId, projectKey, @@ -1096,7 +1152,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'listFeatureTargeting', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } return await handleZodiosValidationErrors( () => fetchTargetingForFeature( @@ -1108,7 +1169,7 @@ export const featureToolHandlers: Record = { 'fetchTargetingForFeature', ) }, - (orgId: string, projectKey: string) => + (orgId: string, projectKey: string | undefined) => generateFeatureDashboardLink( orgId, projectKey, @@ -1123,7 +1184,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'updateFeatureTargeting', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } const { feature_key, environment_key, ...configData } = validatedArgs @@ -1139,7 +1205,7 @@ export const featureToolHandlers: Record = { 'updateFeatureConfigForEnvironment', ) }, - (orgId: string, projectKey: string) => + (orgId: string, projectKey: string | undefined) => generateFeatureDashboardLink( orgId, projectKey, @@ -1154,7 +1220,12 @@ export const featureToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'getFeatureAuditLogHistory', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } return await handleZodiosValidationErrors( () => getFeatureAuditLogHistory( @@ -1166,7 +1237,7 @@ export const featureToolHandlers: Record = { 'getFeatureAuditLogHistory', ) }, - (orgId: string, projectKey: string) => + (orgId: string, projectKey: string | undefined) => generateFeatureDashboardLink( orgId, projectKey, diff --git a/src/mcp/tools/index.ts b/src/mcp/tools/index.ts index 336fb22e6..596b76469 100644 --- a/src/mcp/tools/index.ts +++ b/src/mcp/tools/index.ts @@ -30,12 +30,17 @@ import { } from './customPropertiesTools' /** - * Type guard to ensure the API client is a DevCycleApiClient instance + * Type guard to ensure the API client implements IDevCycleApiClient interface + * Accepts both DevCycleApiClient (CLI) and WorkerApiClient (Worker) implementations */ function isDevCycleApiClient( apiClient: IDevCycleApiClient, -): apiClient is DevCycleApiClient { - return apiClient instanceof DevCycleApiClient +): apiClient is IDevCycleApiClient { + return ( + apiClient && + typeof apiClient.executeWithLogging === 'function' && + typeof apiClient.executeWithDashboardLink === 'function' + ) } /** diff --git a/src/mcp/tools/projectTools.ts b/src/mcp/tools/projectTools.ts index 0ae0ed9df..0f189922e 100644 --- a/src/mcp/tools/projectTools.ts +++ b/src/mcp/tools/projectTools.ts @@ -17,8 +17,11 @@ import { ToolHandler } from '../server' // Helper functions to generate project dashboard links const generateProjectDashboardLink = ( orgId: string, - projectKey: string, + projectKey: string | undefined, ): string => { + if (!projectKey) { + throw new Error('Project key is required for project dashboard link') + } return `https://app.devcycle.com/o/${orgId}/p/${projectKey}` } @@ -26,7 +29,10 @@ const generateOrganizationSettingsLink = (orgId: string): string => { return `https://app.devcycle.com/o/${orgId}/settings` } -const generateEditProjectLink = (orgId: string, projectKey: string): string => { +const generateEditProjectLink = ( + orgId: string, + projectKey: string | undefined, +): string => { return `https://app.devcycle.com/o/${orgId}/settings/projects/${projectKey}/edit` } @@ -225,6 +231,7 @@ export const projectToolDefinitions: Tool[] = [ // Legacy handlers for backward compatibility export const projectToolHandlers: Record = { list_projects: async (args: unknown, apiClient) => { + console.error('list_projects tool called with args:', args) const validatedArgs = ListProjectsArgsSchema.parse(args) return await apiClient.executeWithDashboardLink( @@ -244,7 +251,12 @@ export const projectToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'getCurrentProject', null, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for getting current project', + ) + } return await handleZodiosValidationErrors( () => fetchProject(authToken, projectKey), 'fetchProject', diff --git a/src/mcp/tools/registry.ts b/src/mcp/tools/registry.ts index d9985a64d..eca105eee 100644 --- a/src/mcp/tools/registry.ts +++ b/src/mcp/tools/registry.ts @@ -81,6 +81,7 @@ export class MCPToolRegistry { if (!tool) { throw new Error(`Unknown tool: ${name}`) } + console.error('Executing tool:', name) return await tool.handler(args, client) } diff --git a/src/mcp/tools/resultsTools.ts b/src/mcp/tools/resultsTools.ts index 3c95c5fc3..025aa59ad 100644 --- a/src/mcp/tools/resultsTools.ts +++ b/src/mcp/tools/resultsTools.ts @@ -23,16 +23,22 @@ import { ToolHandler } from '../server' // Helper functions to generate dashboard links const generateFeatureAnalyticsDashboardLink = ( orgId: string, - projectKey: string, + projectKey: string | undefined, featureKey: string, ): string => { + if (!projectKey) { + throw new Error('Project key is required for feature analytics dashboard link') + } return `https://app.devcycle.com/o/${orgId}/p/${projectKey}/features/${featureKey}/analytics` } const generateProjectAnalyticsDashboardLink = ( orgId: string, - projectKey: string, + projectKey: string | undefined, ): string => { + if (!projectKey) { + throw new Error('Project key is required for project analytics dashboard link') + } return `https://app.devcycle.com/o/${orgId}/p/${projectKey}/analytics` } @@ -152,7 +158,10 @@ export const resultsToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'getFeatureTotalEvaluations', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error('Project key is required for this operation'); + } const { featureKey, ...apiQueries } = validatedArgs return await handleZodiosValidationErrors( @@ -180,7 +189,10 @@ export const resultsToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'getProjectTotalEvaluations', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error('Project key is required for this operation'); + } return await handleZodiosValidationErrors( () => fetchProjectTotalEvaluations( diff --git a/src/mcp/tools/selfTargetingTools.ts b/src/mcp/tools/selfTargetingTools.ts index 9d315f0b7..2ce5c1698 100644 --- a/src/mcp/tools/selfTargetingTools.ts +++ b/src/mcp/tools/selfTargetingTools.ts @@ -220,7 +220,10 @@ export const selfTargetingToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'getSelfTargetingIdentity', null, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error('Project key is required for this operation'); + } return await handleZodiosValidationErrors( () => fetchUserProfile(authToken, projectKey), 'fetchUserProfile', @@ -235,7 +238,10 @@ export const selfTargetingToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'updateSelfTargetingIdentity', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error('Project key is required for this operation'); + } return await handleZodiosValidationErrors( () => updateUserProfile(authToken, projectKey, { @@ -251,7 +257,10 @@ export const selfTargetingToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'listSelfTargetingOverrides', null, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error('Project key is required for this operation'); + } return await handleZodiosValidationErrors( () => fetchProjectOverridesForUser(authToken, projectKey), 'fetchProjectOverridesForUser', @@ -266,7 +275,10 @@ export const selfTargetingToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'setSelfTargetingOverride', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error('Project key is required for this operation'); + } return await handleZodiosValidationErrors( () => updateOverride( @@ -293,7 +305,10 @@ export const selfTargetingToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'clearFeatureSelfTargetingOverrides', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error('Project key is required for this operation'); + } await handleZodiosValidationErrors( () => deleteFeatureOverrides( @@ -316,7 +331,10 @@ export const selfTargetingToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'clearAllSelfTargetingOverrides', null, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error('Project key is required for this operation'); + } await handleZodiosValidationErrors( () => deleteAllProjectOverrides(authToken, projectKey), 'deleteAllProjectOverrides', diff --git a/src/mcp/tools/variableTools.ts b/src/mcp/tools/variableTools.ts index 5fde30132..4ac19bc56 100644 --- a/src/mcp/tools/variableTools.ts +++ b/src/mcp/tools/variableTools.ts @@ -23,8 +23,11 @@ import { DevCycleApiClient } from '../utils/api' // Helper function to generate variable dashboard links const generateVariablesDashboardLink = ( orgId: string, - projectKey: string, + projectKey: string | undefined, ): string => { + if (!projectKey) { + throw new Error('Project key is required for variables dashboard link') + } return `https://app.devcycle.com/o/${orgId}/p/${projectKey}/variables` } @@ -312,7 +315,12 @@ export const variableToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'listVariables', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } return await handleZodiosValidationErrors( () => fetchVariables(authToken, projectKey, validatedArgs), 'fetchVariables', @@ -327,7 +335,12 @@ export const variableToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'createVariable', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } return await handleZodiosValidationErrors( () => createVariable(authToken, projectKey, validatedArgs), 'createVariable', @@ -342,7 +355,12 @@ export const variableToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'updateVariable', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } const { key, ...updateData } = validatedArgs return await handleZodiosValidationErrors( @@ -360,7 +378,12 @@ export const variableToolHandlers: Record = { return await apiClient.executeWithDashboardLink( 'deleteVariable', validatedArgs, - async (authToken: string, projectKey: string) => { + async (authToken: string, projectKey: string | undefined) => { + if (!projectKey) { + throw new Error( + 'Project key is required for this operation', + ) + } await handleZodiosValidationErrors( () => deleteVariable( diff --git a/src/mcp/utils/api.ts b/src/mcp/utils/api.ts index eab0568bd..5f08df695 100644 --- a/src/mcp/utils/api.ts +++ b/src/mcp/utils/api.ts @@ -89,7 +89,10 @@ export class DevCycleApiClient implements IDevCycleApiClient { public async executeWithLogging( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, requiresProject = true, ): Promise { console.error( @@ -107,7 +110,9 @@ export class DevCycleApiClient implements IDevCycleApiClient { setMCPToolCommand(operationName) const authToken = this.auth.getAuthToken() - const projectKey = requiresProject ? this.auth.getProjectKey() : '' + const projectKey = requiresProject + ? this.auth.getProjectKey() + : undefined return await operation(authToken, projectKey) } catch (error) { console.error( @@ -124,8 +129,15 @@ export class DevCycleApiClient implements IDevCycleApiClient { public async executeWithDashboardLink( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, - dashboardLink: (orgId: string, projectKey: string, result: T) => string, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, + dashboardLink: ( + orgId: string, + projectKey: string | undefined, + result: T, + ) => string, ): Promise<{ result: T; dashboardLink: string }> { const result = await this.executeWithLogging( operationName, From d1bda556ec883660a085d8c4cfd69b161738ed71 Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Mon, 28 Jul 2025 16:23:04 -0400 Subject: [PATCH 10/31] feat: fix tests, add project selection tool --- mcp-worker/src/apiClient.ts | 79 ++++++++++++++++++++++------ mcp-worker/src/index.ts | 94 ++++++++++++++++++---------------- src/mcp/api/interface.test.ts | 9 ++-- src/mcp/api/interface.ts | 13 +++++ src/mcp/tools/registry.test.ts | 63 ++++++++++++++++++++--- 5 files changed, 190 insertions(+), 68 deletions(-) diff --git a/mcp-worker/src/apiClient.ts b/mcp-worker/src/apiClient.ts index c652e3587..5cb16ea61 100644 --- a/mcp-worker/src/apiClient.ts +++ b/mcp-worker/src/apiClient.ts @@ -9,6 +9,7 @@ export class WorkerApiClient implements IDevCycleApiClient { constructor( private props: UserProps, private env: Env, + private storage?: DurableObjectStorage, ) {} /** @@ -17,11 +18,14 @@ export class WorkerApiClient implements IDevCycleApiClient { async executeWithLogging( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, requiresProject: boolean = true, ): Promise { const authToken = this.getAuthToken() - const projectKey = this.getProjectKey() + const projectKey = await this.getProjectKey() if (requiresProject && !projectKey) { throw new Error('No project key found') @@ -35,7 +39,7 @@ export class WorkerApiClient implements IDevCycleApiClient { }) try { - const result = await operation(authToken, projectKey || '') + const result = await operation(authToken, projectKey) console.log(`Worker MCP ${operationName} completed successfully`) return result } catch (error) { @@ -55,11 +59,18 @@ export class WorkerApiClient implements IDevCycleApiClient { async executeWithDashboardLink( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, - dashboardLink: (orgId: string, projectKey: string, result: T) => string, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, + dashboardLink: ( + orgId: string, + projectKey: string | undefined, + result: T, + ) => string, ): Promise<{ result: T; dashboardLink: string }> { const authToken = this.getAuthToken() - const projectKey = this.getProjectKey() + const projectKey = await this.getProjectKey() const orgId = this.getOrgId() console.log(`Worker MCP ${operationName} (with dashboard link):`, { @@ -103,18 +114,56 @@ export class WorkerApiClient implements IDevCycleApiClient { } /** - * Get the project key from JWT claims or environment variables + * Get the project key from Durable Object storage first, then fall back to JWT claims */ - private getProjectKey(): string | undefined { - const claims = this.props.claims as DevCycleJWTClaims + private async getProjectKey(): Promise { + // Priority 1: Check Durable Object storage for selected project + if (this.storage) { + try { + const selectedProjectKey = + await this.storage.get('selectedProjectKey') + if (selectedProjectKey) { + return selectedProjectKey as string + } + } catch (error) { + console.warn( + 'Failed to get selected project from storage:', + error, + ) + } + } + // Priority 2: Fall back to JWT claims + const claims = this.props.claims as DevCycleJWTClaims return claims?.project_key } + /** + * Set the selected project (stored in Durable Object) + */ + async setSelectedProject(projectKey: string): Promise { + if (!this.storage) { + throw new Error('Storage not available for project selection') + } + await this.storage.put('selectedProjectKey', projectKey) + } + + /** + * Check if user has a project key available (from storage or JWT claims) + */ + public async hasProjectKey(): Promise { + try { + const projectKey = await this.getProjectKey() + return !!projectKey + } catch { + return false + } + } + /** * Get the organization ID from JWT claims */ - private getOrgId(): string { + public getOrgId(): string { const claims = this.props.claims as DevCycleJWTClaims if (claims?.org_id) { @@ -127,7 +176,7 @@ export class WorkerApiClient implements IDevCycleApiClient { /** * Get the user ID from JWT claims (for logging purposes) */ - private getUserId(): string { + public getUserId(): string { const claims = this.props.claims as DevCycleJWTClaims return claims?.sub || claims?.email || 'unknown' } @@ -135,9 +184,9 @@ export class WorkerApiClient implements IDevCycleApiClient { /** * Check if the user has access to the required project */ - public hasProjectAccess(projectKey?: string): boolean { + public async hasProjectAccess(projectKey?: string): Promise { try { - const userProjectKey = this.getProjectKey() + const userProjectKey = await this.getProjectKey() return !projectKey || userProjectKey === projectKey } catch { return false @@ -147,11 +196,11 @@ export class WorkerApiClient implements IDevCycleApiClient { /** * Get user context information for debugging */ - public getUserContext() { + public async getUserContext() { const claims = this.props.claims as DevCycleJWTClaims let projectKey: string | undefined try { - projectKey = this.getProjectKey() + projectKey = await this.getProjectKey() } catch { projectKey = undefined } diff --git a/mcp-worker/src/index.ts b/mcp-worker/src/index.ts index 8448b5393..336705b87 100644 --- a/mcp-worker/src/index.ts +++ b/mcp-worker/src/index.ts @@ -4,6 +4,10 @@ import { McpAgent } from 'agents/mcp' import { createAuthApp, tokenExchangeCallback } from './auth' import { WorkerApiClient } from './apiClient' import { MCPToolRegistry, registerAllTools } from '../../src/mcp/tools' +import { + projectSelectionToolDefinitions, + projectSelectionToolHandlers, +} from './projectSelectionTools' import type { UserProps, Env } from './types' /** @@ -33,18 +37,39 @@ export class DevCycleMCP extends McpAgent< * Initialize the MCP server with tools and handlers */ async init() { + // Initialize the Worker-specific API client with OAuth tokens and Durable Object storage + this.apiClient = new WorkerApiClient( + this.props, + this.env, + this.state.storage, + ) + console.log('Initializing DevCycle MCP Worker', { - userId: this.getUserId(), - orgId: this.getOrgId(), - hasProject: this.hasProjectKey(), + userId: this.apiClient.getUserId(), + orgId: this.apiClient.getOrgId(), + hasProject: await this.apiClient.hasProjectKey(), }) - // Initialize the Worker-specific API client with OAuth tokens - this.apiClient = new WorkerApiClient(this.props, this.env) - - // Register all tools from the shared registry + // Register all shared tools from the shared registry registerAllTools(this.registry) + // Register Worker-specific project selection tools + const projectSelectionTools = projectSelectionToolDefinitions.map( + (toolDef) => ({ + name: toolDef.name, + description: toolDef.description || '', + inputSchema: toolDef.inputSchema, + outputSchema: toolDef.outputSchema, + handler: async (args: unknown, apiClient: any) => { + const legacyHandler = + projectSelectionToolHandlers[toolDef.name] + return await legacyHandler(args, apiClient) + }, + }), + ) + + this.registry.registerMany(projectSelectionTools) + console.log( `Registered ${this.registry.size()} MCP tools:`, this.registry.getToolNames(), @@ -57,7 +82,7 @@ export class DevCycleMCP extends McpAgent< {}, async () => { try { - const userContext = this.apiClient.getUserContext() + const userContext = await this.apiClient.getUserContext() return { content: [ { @@ -105,7 +130,7 @@ export class DevCycleMCP extends McpAgent< try { console.log(`Executing tool: ${tool.name}`, { args, - userId: this.getUserId(), + userId: this.apiClient.getUserId(), }) // Execute tool with Worker-specific API client that uses OAuth tokens @@ -136,6 +161,8 @@ export class DevCycleMCP extends McpAgent< responseText = JSON.stringify(result, null, 2) } + console.log(`Tool ${tool.name} completed successfully`) + return { content: [ { @@ -145,25 +172,31 @@ export class DevCycleMCP extends McpAgent< ], } } catch (error) { - console.error(`Tool execution error: ${tool.name}`, { + console.error(`Tool ${tool.name} error:`, { error: error instanceof Error ? error.message : String(error), args, - userId: this.getUserId(), + userId: this.apiClient.getUserId(), }) - // Standardized error handling across all tools - const errorMessage = - error instanceof Error - ? error.message - : String(error) return { content: [ { type: 'text', - text: `The call to ${tool.name} failed: ${errorMessage}`, + text: JSON.stringify( + { + error: + error instanceof Error + ? error.message + : String(error), + tool: tool.name, + args, + }, + null, + 2, + ), }, ], } @@ -174,33 +207,6 @@ export class DevCycleMCP extends McpAgent< console.log('DevCycle MCP Worker initialization completed') } - - /** - * Get user ID from claims for logging - */ - private getUserId(): string { - const claims = this.props.claims as any - return claims?.sub || claims?.email || 'unknown' - } - - /** - * Get organization ID from claims - */ - private getOrgId(): string { - return (this.props.claims as any)?.org_id || 'unknown' - } - - /** - * Check if user has project key available - */ - private hasProjectKey(): boolean { - try { - this.apiClient.getUserContext() - return true - } catch { - return false - } - } } // Initialize the Hono app with non-OAuth routes only diff --git a/src/mcp/api/interface.test.ts b/src/mcp/api/interface.test.ts index 0e22ea741..c033f471a 100644 --- a/src/mcp/api/interface.test.ts +++ b/src/mcp/api/interface.test.ts @@ -147,7 +147,7 @@ describe('API Interface Abstraction', () => { const mockOperation = async ( authToken: string, - projectKey: string, + projectKey: string | undefined, ) => { expect(authToken).to.equal('worker-token') expect(projectKey).to.equal('worker-project') @@ -224,10 +224,13 @@ describe('API Interface Abstraction', () => { ) const client = new WorkerDevCycleApiClient(authContext) - const mockOperation = async () => ({ featureKey: 'test-feature' }) + const mockOperation = async ( + authToken: string, + projectKey: string | undefined, + ) => ({ featureKey: 'test-feature' }) const dashboardLink = ( orgId: string, - projectKey: string, + projectKey: string | undefined, result: any, ) => `https://app.devcycle.com/o/${orgId}/p/${projectKey}/features/${result.featureKey}` diff --git a/src/mcp/api/interface.ts b/src/mcp/api/interface.ts index 905588a9e..3e5543a8e 100644 --- a/src/mcp/api/interface.ts +++ b/src/mcp/api/interface.ts @@ -51,6 +51,19 @@ export interface IDevCycleApiClient { result: T, ) => string, ): Promise<{ result: T; dashboardLink: string }> + + /** + * Set the selected project (Worker implementation only) + * This method is used by project selection tools to persist user's project choice + * @param projectKey - The project key to select + */ + setSelectedProject?(projectKey: string): Promise + + /** + * Check if a project key is currently available + * @returns True if a project key is available from any source + */ + hasProjectKey?(): Promise } /** diff --git a/src/mcp/tools/registry.test.ts b/src/mcp/tools/registry.test.ts index b736c9fd1..379650df8 100644 --- a/src/mcp/tools/registry.test.ts +++ b/src/mcp/tools/registry.test.ts @@ -1,16 +1,60 @@ import { expect } from '@oclif/test' import { MCPToolRegistry } from './registry' import { IDevCycleApiClient } from '../api/interface' -import { registerProjectTools } from './projectTools' -import { registerVariableTools } from './variableTools' -import { registerEnvironmentTools } from './environmentTools' +import { projectToolDefinitions, projectToolHandlers } from './projectTools' +import { variableToolDefinitions, variableToolHandlers } from './variableTools' +import { + environmentToolDefinitions, + environmentToolHandlers, +} from './environmentTools' + +// Helper function to create tool definitions from definitions and handlers +function createToolDefinitions( + toolDefinitions: any[], + toolHandlers: Record, +) { + return toolDefinitions.map((toolDef) => ({ + name: toolDef.name, + description: toolDef.description, + inputSchema: toolDef.inputSchema, + handler: async (args: any, apiClient: any) => { + const legacyHandler = toolHandlers[toolDef.name] + return await legacyHandler(args, apiClient) + }, + })) +} + +// Helper functions to register different tool types +function registerProjectTools(registry: MCPToolRegistry): void { + registry.registerMany( + createToolDefinitions(projectToolDefinitions, projectToolHandlers), + ) +} + +function registerVariableTools(registry: MCPToolRegistry): void { + registry.registerMany( + createToolDefinitions(variableToolDefinitions, variableToolHandlers), + ) +} + +function registerEnvironmentTools(registry: MCPToolRegistry): void { + registry.registerMany( + createToolDefinitions( + environmentToolDefinitions, + environmentToolHandlers, + ), + ) +} // Mock API client for testing class MockApiClient implements IDevCycleApiClient { async executeWithLogging( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, requiresProject = true, ): Promise { // Mock implementation - just return a test result @@ -20,8 +64,15 @@ class MockApiClient implements IDevCycleApiClient { async executeWithDashboardLink( operationName: string, args: any, - operation: (authToken: string, projectKey: string) => Promise, - dashboardLink: (orgId: string, projectKey: string, result: T) => string, + operation: ( + authToken: string, + projectKey: string | undefined, + ) => Promise, + dashboardLink: ( + orgId: string, + projectKey: string | undefined, + result: T, + ) => string, ): Promise<{ result: T; dashboardLink: string }> { // Mock implementation const result = await operation('test-token', 'test-project') From 2e19c627546b32fc7779524f4616a5d912f14558 Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Mon, 28 Jul 2025 16:23:14 -0400 Subject: [PATCH 11/31] feat: add projectSelectionTools.ts --- mcp-worker/src/projectSelectionTools.ts | 173 ++++++++++++++++++++++++ 1 file changed, 173 insertions(+) create mode 100644 mcp-worker/src/projectSelectionTools.ts diff --git a/mcp-worker/src/projectSelectionTools.ts b/mcp-worker/src/projectSelectionTools.ts new file mode 100644 index 000000000..4a02abe03 --- /dev/null +++ b/mcp-worker/src/projectSelectionTools.ts @@ -0,0 +1,173 @@ +import { Tool } from '@modelcontextprotocol/sdk/types.js' +import { handleZodiosValidationErrors } from '../../src/mcp/utils/api' +import { fetchProjects, fetchProject } from '../../src/api/projects' +import { + DASHBOARD_LINK_PROPERTY, + PROJECT_KEY_PROPERTY, +} from '../../src/mcp/tools/commonSchemas' +import { ToolHandler } from '../../src/mcp/server' + +// Helper functions to generate dashboard links +const generateProjectDashboardLink = ( + orgId: string, + projectKey: string | undefined, +): string => { + if (!projectKey) { + throw new Error('Project key is required for project dashboard link') + } + return `https://app.devcycle.com/o/${orgId}/p/${projectKey}` +} + +const generateOrganizationProjectsLink = (orgId: string): string => { + return `https://app.devcycle.com/o/${orgId}/settings/projects` +} + +// ============================================================================= +// TOOL DEFINITIONS +// ============================================================================= + +export const projectSelectionToolDefinitions: Tool[] = [ + { + name: 'select_devcycle_project', + description: + 'Select a project to use for subsequent MCP operations. If no project_key is provided, lists all available projects. Include dashboard link in the response.', + annotations: { + title: 'Select Project', + }, + inputSchema: { + type: 'object', + properties: { + project_key: { + ...PROJECT_KEY_PROPERTY, + description: + 'The project key to select. If not provided, will list all available projects to choose from.', + }, + }, + }, + outputSchema: { + type: 'object', + properties: { + result: { + type: 'object', + properties: { + selectedProject: { + type: 'object', + description: 'The selected project details', + properties: { + key: PROJECT_KEY_PROPERTY, + name: { + type: 'string', + description: 'Project name', + }, + description: { + type: 'string', + description: 'Project description', + }, + }, + }, + availableProjects: { + type: 'array', + description: + 'List of available projects (only shown when no project_key provided)', + items: { + type: 'object', + properties: { + key: PROJECT_KEY_PROPERTY, + name: { + type: 'string', + description: 'Project name', + }, + description: { + type: 'string', + description: 'Project description', + }, + }, + }, + }, + message: { + type: 'string', + description: 'Success or instruction message', + }, + }, + }, + dashboardLink: DASHBOARD_LINK_PROPERTY, + }, + required: ['result', 'dashboardLink'], + }, + }, +] + +// ============================================================================= +// TOOL HANDLERS +// ============================================================================= + +export const projectSelectionToolHandlers: Record = { + select_devcycle_project: async (args: unknown, apiClient) => { + const validatedArgs = args as { project_key?: string } + + // If no project key provided, list available projects + const projectKey = validatedArgs.project_key + if (!projectKey) { + return await apiClient.executeWithDashboardLink( + 'listProjectsForSelection', + validatedArgs, + async (authToken: string) => { + const projects = await handleZodiosValidationErrors( + () => + fetchProjects(authToken, { + page: 1, + perPage: 100, + sortBy: 'name', + sortOrder: 'asc', + }), + 'fetchProjects', + ) + + return { + availableProjects: projects.map((project: any) => ({ + key: project.key, + name: project.name, + description: project.description || '', + })), + message: + 'Available projects listed. Call this tool again with a project_key to select one.', + } + }, + generateOrganizationProjectsLink, + ) + } + + // Select the specified project + return await apiClient.executeWithDashboardLink( + 'selectProject', + validatedArgs, + async (authToken: string) => { + // Fetch the specific project to verify it exists and user has access + const selectedProject = await handleZodiosValidationErrors( + () => fetchProject(authToken, projectKey), + 'fetchProject', + ) + + // Set the selected project in storage + if (apiClient.setSelectedProject) { + await apiClient.setSelectedProject(projectKey) + } else { + throw new Error( + 'Project selection not supported in this environment', + ) + } + + return { + selectedProject: { + key: selectedProject.key, + name: selectedProject.name, + description: selectedProject.description || '', + }, + message: `Project '${selectedProject.name}' (${selectedProject.key}) has been selected for subsequent MCP operations.`, + } + }, + (orgId: string) => + generateProjectDashboardLink(orgId, validatedArgs.project_key), + ) + }, +} From 4009967db50df2b91890d214120cdaf097820aa8 Mon Sep 17 00:00:00 2001 From: Jonathan Norris Date: Tue, 29 Jul 2025 15:46:12 -0400 Subject: [PATCH 12/31] feat: new mcp tool format working with zod schemas --- .nvmrc | 2 +- mcp-worker/.yarn/install-state.gz | Bin 235210 -> 235031 bytes mcp-worker/package.json | 1 - mcp-worker/src/apiClient.ts | 48 +-- mcp-worker/src/auth.ts | 122 ++++---- mcp-worker/src/index.ts | 304 ++++++++++++------- mcp-worker/src/projectSelectionTools.ts | 58 ++-- mcp-worker/src/types.ts | 24 +- mcp-worker/tsconfig.json | 4 +- mcp-worker/worker-configuration.d.ts | 6 +- mcp-worker/yarn.lock | 3 +- package.json | 5 +- src/mcp/index.ts | 23 +- src/mcp/server.ts | 186 ++++++------ src/mcp/tools/index.ts | 5 - src/mcp/tools/projectTools.ts | 379 +++++++++--------------- src/mcp/tools/registry.ts | 2 + src/mcp/types.ts | 56 +++- yarn.lock | 24 +- 19 files changed, 623 insertions(+), 629 deletions(-) diff --git a/.nvmrc b/.nvmrc index 35d2d08ea..23222029f 100644 --- a/.nvmrc +++ b/.nvmrc @@ -1 +1 @@ -22.12 +22.* diff --git a/mcp-worker/.yarn/install-state.gz b/mcp-worker/.yarn/install-state.gz index 68cd52708b95b18e4e50eaa8e60716501e7b2e02..6b6215accf9dc3745f915d8dba947114019c1ef9 100644 GIT binary patch delta 180963 zcmV)3K+C_%tqzy04zT&Rf8BOPJ(lY{#I_t;KEOtT+-C%gc(?4mu!WH?g$DJ3SdPpaba z=HiyK3dpw<`lA^H&@+v_wxAgfX87cQZr1%m0!OZEu=DLw2|c?Gd7^aw2t$Bey*7HI zuk5z9f>oqanuORB0-_H3`R09E{yc3!cUpDCbU`|y?O79(e>FaW24wjaAt_NaQpjCJ zl*5*At`C%4KiK+@G1g}H+>oGRb@FwI4|rpw1sW09jx0h!81xhf$;1NV0S*Qfz18eG z9zCOPgjQ9_(w&F{7rxe}V1m{AZIR?Hj;97UjQHC9Wz3O`l*_cDOu2OBlp5ut@92Ts zvd^J`Vs5b!e>e0^o5ZLCa4UnvLiq73DX=URO_we6f}8ROwQf5f z$q4{Sf9?xq1vJ^FJxeNFojP9bcUgPX1k(IOpI*Scn?xF0kLi5*N3G1V>^UMI8<$#t zv-vC*Vr^Qtj{6e^OT+(sYPNghgVDoC!S17rH0m@1R@XpYwN>Kw;&#Yn8vC^fT;YC6r z=zeCqm{Rm2Q?3m)7uN&3^-@-=6+AUQ>NTrU@5MBWBIoXc`9V0l%T`wdh6;qlhvBX2 zcNVk`J>M97cZJd2`hv0!f_$NO*;Oxt;sS4Qvtd3gBF8hZEdzvA5Cf9(T;g#S0Ap}Y ze_dvGLA;;Uk3uU4Y=GO=e$j}D8wW|2%Wvq)B z+~_K-FzUi@ySMm4t&AaOc5o%;d+drj3|aT=;Aqgyv#TzW}wF&R?a@810JV8~| zIo)mr<&yY8S7nwr^1Q`RD5)cm>LBkj^pEm-d#}KB3n>xL>QKhUj@&jEf=?)r^`n5u zqP3lF^c@S8vV{Z*P+-jyp+1lij?J;)7jvuEY+dYsR==JJlF|Hyji;-9#^uUclXJ41O`jXZLlrsdP9CE}x zKL<5I77rdEqSXWvuNt2qKoj#Lf3`qlp;h%_>812%V|^Rc-fKFMc)IA*&(T_*T-(ov zF!EwpL|EF-cI#ZTpvXpPlSgjLwb2zOQO>@~4p$OxsfQSKsf1+Ghj~9u| zLIkO}UU>vFW``Ur$In3xip*cU*LxQoD&#YHK|ySV`De)Q>HY>u0UdCDJYpPc`@u#8 zl7pQxNa`?X{!VEym1+wGA;Je~G&uDU%=nkHD@rE5@mPz|&A9d02iM*zo&MSs&po1F zB2-3HDa=$OYC-%p>Ue;xe{&m9mM)lek-@PuWfV!@P3h2p4HA|J*so1{6E}nb7y6ic zjkgc&1p4ZXR@Djk2HLi3ZgW0Fp=ll9+T>YRy$8u2v7xs*nP=mAyL636bZ#DbJ|e-V zv*{JiTg+ns=+B%0AEiF324^2;?8T~m)jd{>AeFk60xn>2jrw5We@H}vV1-36Xx#_k zp>`X%wrZ1d6{R}I=Vkcm!h1*RCRszv$j$>uylj%VJiguZli_&8Td z7uJBKy^f1KtL<8H8O6s4hy)N+D{Y$@-P5gEoq1 zjIeohOZ2kF>^9fLn1oQYmuFOgG;9d6lA2;C0!Z?!%AHRWMM?v-`|=bNo1pD==eU^h zqQ@ep32d-I*Sa$7UT2>)&V8A!JSlwb;h`;MPoSl@zP7LBf6qe)UNp!v8pu>YgE326 z$}aRV+X(t1*a)<5CxjI6W=>|1uF;jQSe|-DkW{n89G+9KM7YACV&8CcmD5_E?D%V4 zBW#m|@H*=QZn`DSX$DXuK0gdekjlCD_7q5*>4@apJk)`EqWlRp$ zXgw=F01iJ0V;6M{Da!S__JY1zpfuvsVS_OtY78Z~f3^;Q@%m6s(r(jzv{$^AZDa(5 zvSQ=n&4lM>6MyQy&o>3&=(_HB<~l+L)&NQ2#ah|o6Z@qYvy?X2Vz&!!-08XsRHmuC z;Ijc6%S%3&;$5w_N68D7QP)cs!x_rk3J!ifhUYaN$CDEB;V~O?vX1tKWel-h-37km z@k3~9f13oqPiTeNY{RKo#;P4AY!|`Yc*tr<@=Aa$Vmrd@?1a~(pa&@DTA-^}{2BGl z7oIXmEwogSaHyzF_UNz$ahLnE>u})dqv{^!>NTUB z#Ya{Sw|RGd+5oUD$2(-v1&@hOpodxo47cC_Lpp$!QAxJOVgWIOnq#%ebz1=4Z!{#9~tI0)tCfmULR5|JlLz#rPQWLApGdbh%#N)k<5G?U+os)&~%RB7if$+UBE~0DA zM{5u!b`viE6~$epCOVIy`}vaFW73>fe>)m>Zq8wNKo|-6T!THQj>0_jSu~&z!c{mM z%k3axh)`7G7D{K=wq)rk1mQuO1eW;Z7`8x1Q%F^Z-8t%w!|pdhmGgCFTFiCTYXh5$nWmd*z)FP_do0sqAbscYUasn0!Jg4r1iw z7GH|R+V^^waC9|5|D-gPHuIL647|_OGN<=(_)!a?B)pTH#8d)urIYf+V}HKlR0(BH zXsNib1kwY7x+RSq$};9b`3mE#kmDD=7c_IO!f3a~6Y|maUc=Wk>stvNVoM=)Cb`Vd zw?<8bhY0SiMCJSi2#X`8UcZ-Mx|Z(qNF^5HpeTem-Ph>a_O1<_+45xeBXd#P;m z0(6cec_VHCodywh{Xx{apH^R-nbX0hWaU_#mzWoP(S+Qu6sPfI+tI792MuC2*x-su zwqgovyJ5ct{ZCoBB__}ZEU0}FIf)SdzQswF#)x@WzLcC*f$}bT8GjES02zDm^&3!% z@HHmSIdWna6TU9IsURT;b!SJoI}LvYBSXCYXtVoG#(fI%0wT2Wl?lZ(Ik3mi z6J#TH9$Z3hJ8&TE%Yh-Pw(JzIB8a|$_%_69WFwQR6#LQg&i+VRVyqsPKv@Y1Sq_}d zk6i4ynmMaS<9ln9uj^$_aSjocEZSNxbb4!m%b#)R<`T@CzJCT!866jbk1u*X*dkFu zx#Dr>v;Qh+jQH3>4Ia8}%%J5kaGYEQL?2feqY>}ekn+%tIGlwrm-Em;t=$Gw21zgR z8bZd{a0N4SQ2epkFa1n-U$GA=fd!)JU4?CfrcVdqhZ7}Ron#B=Rbpzk6!6js*KO63 zkPC|8tyc7YY=3LWlR=O$kR4CRP>c_68!z3620Nu;!|&}DFr?ND!A`n-Kv9kgyO+}m zY+PxOK+WpD4N49!X&|c;0cl0%EK7*+Aj2Nx9}oH5?(k%~^!Ml1#7%JA0tjPnW_FO{ zSh}cike|NmC<`R$3zLpQEOpzl4Ryh&7wHkvQL7ORdw*j<#(-aNxHpb7j>E~LAV{x( zj}Wz?s*Jj8mlr>knS1RccAxL~0K7w)4@+cB(k$vv{Ds*M5w;BgB*r4h5#wzS>K5ns zB~Gz1uoca{PbUex2P%*#383d}7G(XhDrqQZNqV?Rs5QC_T2d&B(YI8uxM$KkAuh-1 ztjCR<$$u$atz=x2ODO<9S6gsO{L*DSy6^N-!O>4N`#GajiV)BZydE4&chU zbV8Z|lR$#Pnq{6ds5Hp1z_dvQ?I4)tv~^I0-nHv7fEfGPJ{LRK(z5Mjm5Z<7oJ~xm z4P>h>ZB>2Q=BMTE0MxA-S+^kBZ~8bbwtafOeA-bLIraeAy~jZ zUIZeO;0c&l4;`+ykV<8>{gorI4WBo<0wSNti z3a|Q{WLWgM&MGUdU#jNS*z(2X%)W%DoHG-Q3L_k^q{S}cD|e#{gkBAwo|k;!3kE0I zk;0sO7L8+kQIPe?0_}p2x!B4!`>Z*0w?sF{`#|gv=fOd9=`Occa?Iw%gnm2;D(U;h zhDYDK6ftzBP{RR^^R6+M5R8yrC4cJ&hB#N!5KC@rNQReETqa>evL40>dpIHjAa~yN z%C*YG3B?C%)sOOugh}A3#?b1nw#l_rblF~nOyMe=IitY6tFRgCsQJ1n!B_{pzA2`H z`?&t2S|!2`Ci5;zIQ{AhY#5|0lhS2n_IOk6*1Gp;qBrYpAcTpS>jilYEq@?k6vDob zj5vB$!ZL`S-FBW!1dR4Xzlj%-0M-dlCR5ChOJTDn>&YdKXQN<4L z6EW_}r+CyZi~eAdb4L1^PJQqLN8krT@Vuk~KP{j_66vr||Hgf$t$!Vp)Z07BjFr>T zd!4qe${^x~khdOd$32vo$q*p{6le$B6lW_yy4?SbT7_%Q%XFw2$HSQQWZti1zVuF0_u}1LMQ#_dH1AX@#LVGv>inlGjVN{b-d)e`W#LMf%_+b>PKD>;<2yTBQn@+&%=kELck;P#BG|DB@4a1^)hp`{_-UPfOKJA$q=Wtm=OUn@Pg{^ z1uWWl;cy(K%zuUliY7iv>p&xAP9u9vMzO&>m_fv17yj%zNsu*c;W((SPaS**TPsTP zJns0~IoG1yMWH=;APmVz!op0>rjEe2s6uXPb|G*J0P&1qfNN7BUQua5Kt+Z~EJ@n) zM<5>-^nYtdUt0$zT|@$%cVJ3i==v=2>_J1NZ;+4pTz_@zMBzT^(Kw@?4(t zi0F2P-;C`Q?YzAt_E`@RO%VS15puHJfYCFxaW?MfUOo5pr(JLR6-dmNmjq^1%QFF? zl0kwSh!jx}CkI$uKJn!mRO43cp9&vN>hhPGI z_@f}{7=Jm~kR?fo>&Eu&h+xizS95iN+5~I9@i2E@8lW=lyl0!>Ih@yIb|EiJjLi{# z92r!^kC0CDg9MJ^oL&1vCINE-W=~`)-wl{IW6cerDGgeQj;V3B4_v8$eQsHYY@;z! z>maDoX&$bU2R;a%uJ6TkB}4~OPk(#x}QKC!C`A3Jd2C(44t(i#z0^s|$|-D)HP??4v)fe(Xk9v2u1 z!{3O(XdVw#(Jz@y%*$lIj(1U0y zflfH@Ot=PM$cdC&Loao4=byJageg1ePJetH=y5?TvKXFjWPbEV%Oc(NnFVHLOG^da z&Q&;&Lx^x>(?7*)xgbs2xG_7w!MLZs1W&EEZ3eq&F>qEr-YDW&CI@{e(IS&J)1HEn ze>Tah`ha(Mz&UI(%cQV*d`GP1o0PgyS~3|%#|eTyLyYfF(J&WM3+PbETT z$@WFml^hEqc_Otu_F?SS&g^5b4k?4#PM?vcvHIF2WP~7FwMa+_wba%#t4V1OK!pK% z%X;{=_K_JtrLq>&A;KHiaO+33lYb@VG|`P9G4#UG$Qz+svSNqt9;Haf$~QN)E2A)L zy(>K}DGU=O4AUHaLlf`qyjE)q*RCoXuqQV3L8L(AQc~C@7*L=*wJsnnxN8V$$HQtv z*brZg#pJwu1-+nvp>PF36*00}rdWC5CPcxk_d+?7O+b%wS3xmyh*y65h<|jMc?PiD z?iApFNrqa-XLeYzu`KViuv4pd225u<41OrkJAOBuI7%f@5?H3)g-L zLKt-_f_|9eqmf7RcGgNXPFAlVT{Z-yby9sr?FlS_d8vy%`*o`pzzwF*`XjC&?MwV{ zL26;d&*{ltJ>6KsP^b2e_J3d6RU$&zSRoM`4E{b^nG@n)xM^JgrS9W8%W=F6B6cPJ$=U99P3D0ke>hy*NrR4y^*; z2w$M$9Iac6@*>F}(q#0q8BW8Y+Hf&;OZXL(o^4f3c!N*1WnIT|0)HunQi^u6NQE2O z1eDK(w#GWAgKWa7qcykRDnv%V^xjrYpDdQ`b?BaGVMy^yFILVyK793xA*CS|WgE}l z+Q`TO^UsICF%UoD6Nr>!ZVxfpyD171mP#N;h2(fr;bRcB5ieeyDI(bfEs3bUaUDLk zzd27R+hQ1&`Y`Dqk$-IP01bm>Kamxz8AirN$8c6fe1?BV0o}X zVRqi+L7(EXMq-2p@n=05mz9FErn1}sq=18i4=#P#OI_i^(q)m#x4j9m5wCD-WQ--& zZ5x#}<e7Cc!zikAWA0?bKTMLhEo>GUdo5-*cyt52SO}!4M5DJF43? zgij5c#O@Ul5`Ub5(>|amvZ#Rxl|x`$jD;`h2Gj}VPQx0;rh*VE6m&#t$q4F2B0k_c z2PvY6{coKZM-D49)@5O0cq3~@n{s(qlDt}nDniobU^bNEfMDgh!2H0)A ztqd3#(@qO=YOAZ>hEU3nJBfdRqA5-zGm?-k*5?xq0%2-8q!O;OH_0Xe^=0ndLV~~` zk|n8DN?FK}NX_$AUvO;(g0sOrV)Xg!k{5agV|~J~syOD$$+v3@>BSrG@5bFp=2d0< z0|SQSIDcFV6L}^j;@+n)(-@=GKmbb&uv9?_s9~N^-l%0nrbq zese_TC|1vW1~%dSh9m?Xlp)yG$z&zb2%S=8jeq{)f-1j&i9I4_x!_}I6*emgUt*)b z@ziK$Yigedl1p?@&D%IkN#Ui)EoHQ-DkDd)548Di&q$m(bh_-nLi158lkC<0oZL&# zAs%uTfI<7ogcAY?hOkaiR!AbmC|V3b{%v603H{g{lgov5)`~;%c@dx6oF6b|1VkHh zzJKnC1(gsaQfG(|1o9LwaG58D?L8~>oe%&kRbX(C4;w-6scgW2zk4~%D9DrTwKC#I zN8ex%u?gTfHTIk>=F`M8ZJ1q1R~kig%NyJ40NKYk5w&Zpw=HjIiVDdSqw!a?_`qvI zmV}mVD5X4K_fz8u#*iXmZJvzLcaXK)WPcc*5C>~9#sAg+`}cnHpPlc%jontLpUN}+br>gp1+Ilpf%K<9`cokNYa|j# z|Ev0&e-Xd?Vf*hher2ng&ppYnWKZ(Br1)G?{Jf<2+z^w{*BXERe@97vj^{te^Pl7S z&++`PZ#@4w8~>b*f6m4~XXAf78~^QZ{`q&`f7lrQ=fC{j@8eCzdow#&yLOCn{k1W3 z6o?AIaWBu31V8|e0-`SpH18xHqC#XW+DN}r^R+e^VnpKBSOo2mF!wQzRnl6WxS1(~ zs7hS%z--@GdfgVa7ix>U@so6plSU@rW_Or#?Uydo29tu=M1MZF#2s33$mp?gEG;4Y z&|9CoU$4c~EPeA)@O^`FU@xDb$`{cQBw&@^-Mu@Jw$Xc=A3Yu;oR?ZUW*JU~l!LRC zITb_eN2)X2gK>}XI(o6!2~n3%Je6bw@4Tx~6T;lwkA)9iS(#LpO@Q59R+&5RbBG37 zG3T-RG%s~Uu@4qtGnFLQF$Sqg7iZJi&XZKxTz`0Bmey=U#YJhgKGnsq(qNY>XDjdFIqmMSE%t2IWHQP+t>OvQz0 zUJ0v0|4wK{IeRch9*=&zjZDbdxA~0vDmlxZ@3ZkMSXX^Ii#|7Ie*I* z?KXl&;&G(t8{gw-B8MF1yB`YsU=i8mv+_+|!+f|9ALK&VohF!ivnCHR1DqMG|6GS} zQrVuDmV&7IMrc&FrZ1vk2NxdDwO{TA-G4SLgg2HJfWVjow)E|g}3|b zuz2b7f(<^<36tq_UVO}~Df?pm@R7+)J|^6=QFqUjO=g?RXc9Kf;9cQIKMqTx5Y+8+ z*4;xSYEE&YR;IGcxpNA?1k>!o4vCMN9*sBaEhdwwZ|8O60B*Im#|_B-qJby1xw3IH zPX@Mo%}r3f!|0f0jJZuAv-8P^Cx72O;TKDk%(g(e^;bCdvu;n_`><>AD&zKbCUymNMZoJ(UAp<;^Wi|R&0P?&s^@1Gljpaf67)1g@ zA8qb2Pqxc&1F+1!IpT=4u8r`ZBKXlyy8^zdus^?$w~07T@bxM9`V@Tq9Ta^13eu=`ch*xnVz1_Fu6t`Czl{#JFySs7v_dLx zkiCowqe`<{VlJu`dwBy!Of12Rn>xA`O$57;VmpWNJe8RltjFPo^9hZjrylF zY7W1WsB)4t;ktJna*qY41d+)Simn6PqpP-@k^EOI7a;(Mw7SBD@952nJlgxmikJ1I zde0qvDI$02L;|`SZNnWs^Fvkf_4C<(1>xu;HwP0V6aomx^;()I+}j|FP-(L~NkcT^ zBIitk6O>~+&N>U!F^QMc&@5Wa+1Aq1=2XAa`&_|~vRY7PD=Y79z4XBl42b!!BM>_; zXXu)2z*0uB*u`g$d&jJ>O`BX>W7imblY!nQe;2ztVe4#6I2{-0i((Y^RGdqd0Em;T zF~XiVdy6`xTJ5d7qsv%ZiJ7V6x+L6G-p{g`HFaYITXtDXn2R8q%HjP|s;nN5*3KMW zxH?x}-YUa`&SP`t9hxX==UHcge?w=r?Po@5+QvXw_|Ebjf1nGR51wPFJpJsu- zBW3}PCZBZCE!eYKQHz(s$=b0{;8;VPRhNuePp{{ykVL67)NbxB$NC}eFxQr(f9JJA zI^{jrPdG=K<&w~GV#v8y1MzmmG@UaznzS4#KFNuZ6Kmgn4-?v&B>(h6zCG7B`GqHC z{MLf{i2GAklsKm&ZCiYmIfzaTA(fGIda1F?vRDW=r5!7X?CfTxKPc^moxUlqT4tbY8~g3OpsIPSWm)*Y9?$QE{) zrd4bE?CWRHGu*msizZX%MG`IqU)4I?qE56nd+@>9>Q~)gsNvFBOe?%tfAUu8`B>X} z_FfZh8PfPt@LUktx{CYR%cNDWYm2ZGn(bCnYNyf!u_ZeNVNx_p@i5iAqqPiIo>xiP zCe{Xz<7kZF&rzLz_#C~6FfW}o+8z9}Ue4~Vvy~dP_P)lIf*s`?g4B>F?5U}3?np$i zyI;LCZ5;Mhw{W=j)?$wme~r!fT2)RT(_S!5wY~bOV-?dN4N1n@WxbU}Puv%>k9aXH zC7EKSbYfu6w9U@29mI~dIhB*ArJ$2_7e}$_%m_u+qms2v&Q`_|L&qBcuZ~uJ zDRbR|7_fJgSyri3)yI)R&Q%}vC{kNyW@WU(aQVDqhL2!P@^*Zze-OVLnL+PCDp_q# z_+*cRXua+@^PF?$s=|iprAxLj+v^o|`JQJv=+CjUkUGOUdO9x|o}W@t1o`T3%;BAM zyJ+N=$b{>xjM%PQRNXeR(}Fan*imbrEo+QlNeD90ZFx$}gZOVC^lweP z*L$hU5FR&?H4xywf4yl~iDX79V2uzGXv^(PSlUz}!446! zG4uKme!h=&(6R4o%p^5#wcGlziZ!boK206p3EDe#vvpLZn#Vbk8MU#6uX5X{WtK{+ z&r(JLjr=6L#J3fnt+ScGWYg8El(%cuRC}3OA#KLkN7j~Uf5Y4GMbMrQ3~OYHu`}x9 zoMO>vm|{~jjdMD~&(w0y<@LALY~;O92)?vOwvk8fUYC&x+kFJ(N>rg_8LZvR-fk*% z6=q4YRwk*5{UgCp$tkrLo#f2{9Y`B10{w#;>zcdq4*iCO~mVMk2EJY zwvd`U)X2+v%gJ=YaR(jQk&s>;wL-3f6o)Tv?Dkwxz+LfMe#z6aU&sW z$tbt27035mmCl3qx!*!Q8He6n1kM+VM`siOTz+Ki#Wm zj^?MF+l@UKb^V(AqCLgEhEh*Mj*FZFF9E%n~^>$l6iSpMWT!#^jeHKR_6IgLgPow)lBi)toi1qO{W%8?WU|{ zo3&8tQ)A8PDZQ@mI09f2%h>BYk-vd}3>>WpK)`&^tM^lPo*a zhDd}BGe@oJF0+(=T^HR8o4_%f*NE*TR`0rqpCn9f^L4e2F29UjUfwEe?b$|mlD_9w z9=p-HP@}WZ?6VGL@q4jABWk-)H~L}wCBD2gyQ|ymA$^*^g04h~o^|#zQPkXX%N?~f ze=#yt=gNkvuf((K;36wyvc`zkvqrSVCxGC@iyVRU%X(dVLC`9rEgQ2Zw{B9J4<#qD z4mobh=hLL!ru%3ooLkz+h=Xs+215%rkKN{CdUAOq2x-($e8H4%ZQpj`)DRPrLr7&r#B<#&QsX&>7#;55X)4UH1ohgeMH*)&D$E*Fi*J0u-YezK3%dPK%u<(@ZR@I{ksopY#H@q#vJzI(|?NOha-RBs)H z<-u?{S!v)ic;4tdI(^a0RzyaPb)2vpAikNQ2~s#Qc~w3x=u$Kffx5Eye{+uwxz28E z8q0!{Q)>%FeSVYm;_$PCI7`_+Lklilt#Vf?QM-L3dd*{Ma!y0b7@BQLQ}J#AD3f>kc9 zVG#9e^)!{ebJW1bvi3_l&SlYxwz^$;leg%d9r+MV94t7XZd->s%JBy1ykjEpMB1EJ z7o{XF#gCJ5>Ck_hAe$u|tHz`uX_2&@7-t%G{P8^hXA|cu1+2jFJJIFOMQ2^dZb|eq z+k#vy<}T-$m6=8qZMw5$X<_?W=a6h^xf|yMTXFIC%x*RpK62b~k0m-R6+Ky601}jwoIFRdtjrN5+4(F++vE1$k#Ds9yJt@|0Hy zZ4yQO-o^mvC|b~#jwido{Xjv8jA6%UOkkF@;Iu3cQ2tq+)42kJia^AB~wSM}Ug9qpmW@PCfmMyhZSFg zKYY=8hiDzR>v*_Wku#GC{WI+*E)NvV#1SY z?1X>wFMs&)yFX<7FZsjy!|%Qa?f>7sS)gqs4PYDUJ=?bN;~=8$LDzrfo%$)L2gia1 z!1tc`>&8ref#C2x=B)K9mgyWeu4~PD@vjbNu*Hy3$6IgtjwQI~cJ%w*Z~pP`BES9d zf89U)8IMcl(Dsmd+bzA0VZ=>O6g(t(V+4Px)dcO;`;hE$oA;Ph?z;eOz@p!jeG59} zj>G2;K`PcR-$);20$b{s$FbM5_jA5CTib8`d#A#cA_)*0pYTbP+Lecek6 z;^$r1clULw_GoepLKAD5ac=b6zPP)#9@0QBZjD)L?yxJVG>)y;xp3(iHfXIbl~e9$ zD|OPiYg1{nprkl0>#Pe+2%nt0YkhwJAe<0*oXpvFk7m0p#^M9(XUp>Q-Tl+^`|tiT z?(g>>e!jo|#mBw<;kV!Izx?sfe*66&zWb}+#V_9LuYE~>zSn>H?e~B2um5fNrhL=i zt?n}D>4tjCYsXL(Pdx_%H}oV+JUUBdQ1NigwzJkjae*tOGN7q8j|<9c;oX1ZgRNFr z!pya1){W+$ff52?rTM+i1b%j3U)*XL)!?SM?~Z z%r0J5p`0s{~ z5va4wq86RIsGimis zaB-NR3kp8z_bE1U$^?g==Q=3uD$+$<%Sctr-q8zl;H7;}{!Rwvt?_SYl04rR>3S>O?%c{Tx!Nz4{d=zYuE*}1DvHIIlk!_ z#4G0QRW!f2qiv(fKCG>I)q1gs^pwp~>#KFM31V`WAr7!+1fFr*2^Oh$`igUpw9t7# z5&ABr&kXfi;&6XKkI_LvML{X*RA)ZNZi7LqeQ`(s!JmEi?RUR)Kfm%-`{OTb`(}RA z-rZbHHE#28^ma~5Cu?x`Px2kv6gb;ChMF%C@j+C`pGt_RzPG(>ug`>HEZQ&@$ zj6TXJ-nW%$ca*(k(@xQx-P72x)GzL)FrH*cJQdc3W0ikLl6~0m+X}JkXuw`mE^5_L zAkaG&J}{^j=BR3=To&822whpuEc4-}p4SC7QM5+=nut@*Q5$o%xZ}&a`M-bn!!I4U zU;C>4@mF;4cFM=?^qZzP0xz8))v z$r0z&(Qj`xBD2;TutWs+%IJBp(X@@RW^L3}+^Sw0DjVvjY!wn;`ZlSJ?d<5!66^Qw z{>AP5r>_8Rf1SR+|J^U$)~|f^{`e);Z~9N=udjdFK*MMO2s%@Q%?yec{4g8P&=_cA zP9GWg`gdkS^*oAKssMl_a`W+J1(ISlszC3xADf32JhcpKgRciorngi1{ z8X12Z2)}his8;3}s9Bfj`0^wAr>{hMck&nR>DRt?Ki|`T^Zowu{Mo<$4?pYw^zHY5 z@n7q|`M3QW`=nPIqNzKUY)R18i9>yd4-5Aephj zK>WGb7o)d;8q?kwczyZx{YQVz#s2*-_O@U9%Kh<~-M)XR z^{39KUyIn7zo+(sXa@Vy1v)Did1r4tq_xOJpk~Tu1UU~Jh>~sZ2Fddv%$HFHE#|X# z>gl)3U92&kb;5r7Ht0+}QOJ6jlrP`zyL#`Z#`Tm@S#L^o!;#xm-B+)TmB~WvT%)W9 zZrx*mz-&0SQ_txa%ke4)s|GU15JZ1In35Q5oS^u@S0blci>p0s0P_?1;+FpX|MR=} zr9Sp6U$j5IoBB;{-_&TdmEB=VGjS@jKskngek1*}TzKS5*GIxzv% zE19!hP4-!9I^;5lP)j5Td*9aDJ*}KT$h-F6<+J*0U%Nm4{=R>M`Qx7M z;qSxkU|zrw09fsLEL>}liBIT?Q|VFrMJR4{4XV<2Vw9Plz=~rzJ^YAnGD^0Y8=@R*IvOSKjF?qNsfe1OwdES%;&ucL*0i}<@hstO!@NV&AwRY6kC70wBzeI27I9P zHe~7%c-F3d!E6DmxU+dIPAczPTieqHRGWl5a zRE?QmzP$hRFTai7o!|YfH}`8_y+1mW|L^`y9X~a>z4Zf#*OwuI;T*fNvjEw4_H_z` zsj~llJ9}MhF$iHmw2^;zZ?&i4pBuqw2P`nEESttU)7BJQu%kVAl}7JFM+J(vb>I8t zZT-7EKK{yA@;@3M>o*^bukYGR8&B!D-)LYwQBXxFeB~gD4u4#oQ~4KnX}1Mpx(1te zrY`)QV6UKP=>&nI(yH7NR>wHDN!3GP*d2mkL!oN zwKv(`t(`mG$ZDC)MmR+qkAY;c)3so^=@g+8qX!6w6^ztTwxZ>%n=pqeGWm6xIKwLT z!~(hWi#PZ0?O$qlzxFlzvLe=RWW1X>K@uSo?;YH3eZyy@Erxks#kUmX5UW4T8ETR! zws0&utfm6uu}^qZzF1Y_@v4O>R5cSb&8%4g{>}BFE*tC2d z=sUx}?SixwS=uNmYKMc)v(^S;y7|RAdEA=SW>xhdGg{}4&@nf7ul8UsYm7KA0B0<7 zC7YsH-X3O(4I_ttaWntf`NMbL{`QCSXBmI_`(K()eeHkC_hlJXemaIR6VDOse+QaF zfXH}_;4q_%7M&lf5q2VA$OQc{;5Sj!Gv3oW@@Gh=+Z_6>k|4vHV(r^pfZpdVMj*EYj`%kY;-!Gq<~6}^D}OV0;-=4`zjZnAdB`6Wf_hi4E!9ozaR9hiaAqD+eUgx zySDM>w(Ea_{OTO!BUu3Vl?zk~{2mEJ!{!*)i+nkp`iI}{Z@>H9FZDWK`?`I3Kjo*f zR1?J)fzF?Zjl#*@%mcL%PJENV4!0D5;4Oq?>~Sq1ubXrQ=Wt>cGH#CLxXD)01WO0n zPX6PLp7BJvm@^G1<|wM3HpZ8;|NRg7 zhrjy8am3fYcz=BOvf#0gW+#uq$;@*qgqmJ+t}Nt%2mw+jViG)Z*Lcwt_z4VN8)*yI z-r0ZN-|U1#utQd_!!T8Di_BgOWnFDH-0C=o#m3T^tpTj*bAEAGp^%NyW_pcXgJRxL zNkaYIw(e+a5{CmGq@lZqS8{A*k><4nT}_b^j} z_8C~pLCPg4OI$gQrrOtDRZpihX}u8m20iVXZQRzl)m>B*_1lC#HbGTTA}+5|fU5o7 z95H?Ei}uGWSpBBzC?R%JiZ+noyZGl;mzNrQo6-^hQ5 z0Ie1|T7gM5iCj@ws-(vW9%pHIXlGgLRM1;Tq%3?_Me$I7aXZ<)glAsayOUHzYTSlQ zrYGo@JEhE;!{yQD%LFGaSMjw9VQZcDmZxm;$U@BYE#c37OICIXj@7jW`PPvk~k7o1p0; zqNS`$Qe(}7R8U}T+n00VNigHZRakV-4T%zPr#&#DU7yDgDNN?PP^%4WD9+opvt1{} z1hDQ7ND&iy)0+{{`Es#s}^e^wJCs5|NyW+sP{1#S!>)G{) z)j4r_YlDU|4NqyU&pE_W6uRg1DrY>~Zz$e_cALa$K+p=gL1qna?$R1Xi;eYM+PQd- z+_QXH5dWw71Ix`{>~OyFh5Mrpr|_lysGBhK5QfJmJV`XM)vidG*=FX}kKWZWrxKB1 zk$QXu!tUA#ebJ(jq^fTm%tn}h$snt=lRPCdfX&KY#UB@3&xlg6ql(o8v-RcRzs+s6 zO>4w)#yn@^UdV{vFbq88DDtIhxt6U0OZ-$!CiVDOz&IvIHqXfF1H{yWG*o}o_t>Wk zA!6(194IV2o4tS)NaSBmmHyHFA^+-c(XV~&EBEsq{U826?%t)>lH@plw**=uMNto4 z>8jB{j|9z6!Te$V0J`sgF*i4_N-`@mJ0E=9LI3u~ij$|L+Gl6s&NkQ+0V1WU%!nNk z?&jaO*7LFZ%b)b?q5J=vzbn6R=>GD5{e0x^+GyP1kkBL4l$HvbF6i{+M?H; z7WP-sV}mN`$t%|aF%VNRJ3~s%uoH5-hK<8IcpE&Q)K;RrsQvXJIQl}zA+NYLY8+pxY`{MtbQSK8p9AwsUV$7nLBASU04YFta!+o$`VKiKCVo<6^S`WWBG zpFiB&>^}JV{p>5;zAIl>&L~HFQQyFfDy5YQL3{aHwsdXq#@lNOO9{%v+8iNEXTDaj z)848lwdknIM`r58lk|Nq20p8?BswS81ukQY0=YmD(wn1qf>H zWd@gmmU(J-1!Y=_=FMM}WA@>fv@J0*h*c1V)YFLf(v5BK;q_{w8PfnD-DMO-U%po} zpqGqCZdX>nx|YlL@-Yv-Y%h27ch74o`A(ib`giGh$9wgI;PMvGhkgP_e94aTZw_2?`2vla96a_V`plooE|)+bh$yxh#Gx#A3HknFpAA2I-j zHDAQ_I%wu8dA^A1fpKnp@}x{iXnP$16wbWfa#J?WDZ=<$th!$ z){Evjm$U$gFXe1%w7Apr?WECufA7`%=!m9(su zsM|*c9FTxm;ibf=lS;_BLMXiTFb2VRaNHNi$ZX>$Enp(LU2O=hyQkEPTkE@N$8D)9 z%zti&P?%=Y#6Oe3CeoPL*9amrS7Qx}K&~Sg-4t!Fh|z|0ok~AP0n0XA&Xakf^F-2r zt-)XB2eoH(Fp)e3F8g|zt@FRx={euNcK`8;PQ3ek1!C?^o*sPletvG3eri*~2bFVD zLh_udX5`FipDsIzDTy!Jv#fzwp<>t~GdmG5O5fRLY;s^r;DJ^mS6RvigcTKx6*7gK z$n{g2O3~35I4-G+1ix-SrscwShF*Gq&UH#vjAudO3GBaDRC$`0vc?2VIHQfg?6OM6 z4CNv|Mm+#?GL(HOw4GQattJ^$8N9>=?gLTWwWtB&=i2sd%IR=VM3lFs0QO$W0g}f;+5wolJ?n?At-2e|-Px z)6=I9_NRCE28j>8ct5|X{XYwT&&8HOl?r(2r)LSw@*|%2!I}*)75l83`C>YdYdxgt?cf(q`FF;wW(_+tWc8Al;(vBBnm7TDR`si#xcn4XA~fpH__B;9&9+m zb1WZ-B_My>j!K>72$41$6YuHXESFUJ1?0^9k?`njp>iU5)}~0S}N+w zv1K-uI->WO$YbZgsk;5>hU_%}GM(9#1xmx@lp2YUTB1_7(6gq)R%(HQ;Eb`M2a*)* z^D-|lBp3VAZjA)(izqFJkegOgs;+Uux1oT{M@5vkNU&y=d`x4LT)%$XY|oN)r`O&`ZjO zo}@xg`e3HK`9KCp8XUzg}**F1RIVDnIaT?@uH=IdlST>v;5U(>?C78J9!nY!TU zkQ8HM&sknL>h!tm5(e~m^mYT8Y*02KzDcaCErh0=yn0~&%=z4>r;qkIp5DIs@y)%H zx<_Bb+n4bRn!pWz65yGli>Xure_(;cq0CdP5BATzJBC?Pgusxm`#iYC5ep3r<>C!` z^*CkLOUb*g*x+dDj4FE_&;=t{)YRPoRUs+v^ET&%yB4lkRunS(;Kjr1eVz3Ts#g4c zMMljFN>yER^G{|%jy52m3j=E-L|%1_e7On?uL1Nv6+LKwjbft{orn*V4GOH5F<)g% z|L*I(y|=G<@P&IFL`+}%9Mk5t!Ww|d3#uyz=LKr+$mQW`STd4P8H-e>Wv-Z`AIipZ zd{_gMQ9`TPJPYRPAbnpC{#|S)qaa$aEcjhXIzXI0({FF+YDwAzTDu$REdD~72l3>x zDJm&Q<PTDglCPQYE z*;5+xc0%~iAO7I+oR)eu6IlDQsRJ0J1@kSeex54rzEMUc3=Lebl!Itglv~Itw zSU}na?$wya2hmC#FBL{JY%~N90aMkr5ispT77T_SYeWg&ygR_DZS7Z7&BRV8i^M#+ z=7mM5g?0g3FuKer}cjS<<1>_^p*S8T4}W@pdo7-D3Vs$D|D=} zFX$nE3^YomF^CY59%|;=wF>xEB(Zb1v(HK6a`QFtHuwS|BG;)ndsbeJwhKjWpoH3{ zM}TKs<5kirU75U*M#qyRqf<_&5v<5Ofv)u~Rdi{I78jctg*bcslWfd1(wYUcb6(A8 z@@F958f!pVy)fWIONnG?#4D#kYfLEcC!*hf4j}&Zf4<+G(ER?>*FgA>c5ejy;A?oN zD*5~x&R!Gk*psJ?vT3uR#!E$O=PBtpK{%v@6&Jgl9uq+hW>XM0aA0>P<2(|0PPm;c zPB$a7DFgtPl*k(e*Isxxn2$wCJ8!jDbBMo+RN|vA+N--+zI!J9ECMD@I_R^AvdIV`)WyRRjvy`fd2-f4{ahPoM4M_wo7Z!~3^?Id9&+ zz4x>}_%gmmusug%^0^q_3&ojMPL3~!NSf@FLK+Yc4lf-P7S+DY2un z&(bheLztotRs+#PI-R4#S|%8O?CYPuGA9-!@-xC3nyB;kJk@I}JC9l=w`!t7dN6OB za>xYePB1Nt6Ed79GWqD$dcLe+7*IwXGcV#QWYfBpRw^F2Dt+TJo6cD|IgvSc!N8V@ zG6uZ)K5k#Vzk##%^!;D%g&rP#<$iWY-`eN+^!YjUaE{bja3+W9CS==xMW}Bb&A1eh z%aq(&TEVxh$hB-Vq6QPuB*($I(U*td8NAc_Slw2lAiwv@JEUZ&mZKf|FdZKwT@23B z{{JvBeDpPZ{j`3iI#skh2T$0PI&iCwKueGph6ML!*_o?Zro4}bGG%kV_$Bq;>ylj7 ziE=Gj98AWnM~|fdv9%R{CSa3%wW2-sWk4rM4ba{Eo4aTX-B} zHYUs~<(6hCWdy3@sYzsNl+ZjqtL3e)v+dN=8`$*7;+s( zKVz+a7(tfT4wJ)0nqP)oq1&uV{9kdu-|Qh%4c}Kw%Wz2=fOCdp=ggZDAAX> zd^93oc3h6exovPT;zM5o7BV$iQG9|mjh#=-b_tdhp~K35AQVfTv|d4%Lw|ws46l&M zKqPO1xC0e8ZM*I1>H@Dlck6@!m6TCRkWiPG8Y%jp>Mk#8w=%*leg7 z`|ThHH2Z3Qw$Z}QEpwfsR3oLnyPlT?)+0NR<7g+HSv04gWB~u zUCOHYbltsLPwAAijHkUEY^A`+D+|quWie>{h&x@K)fA~}AFI%8m!D2=ZlBgKZ@&2! ze)I)=ePf?LvV9Zx*|LGxlR{`o(P0P*=H9>>_{x!4@`%wu6K)4PiTLUmu65Z#2er1juiP+Ais2{P&G~a@Pda-)dG9{YJh#cEti8lAv&L_<_S}0(FdweQ%uX{2 ztvUtzx{@K4@7VXGD~~2j?w4H-0W$$lmyr$uC4WxEPi}5&HGVjnvy&Y}rYt!bM#%mF6HVbxEEV8_j2rH0TZpZyj7Bh^liWzYry!HjK*qj@Blk_3XNQK;O zW1mkNY^+kNli1TD9OYpBK}V*fxg$kwPVNlwPu7N~5hq@%B;~P77M0v`xg87t6Vt=} z=6{^4DRJ-f`rylVQ;=*g*gOz|Oj_s~rI{2M!ynlHM)J}rsjaO~bzD7FB+%tZqK1{7Bk4OwQ zNUaNTqT9Rre*HfDGws(m-``8VJo@sz+|^${!(X2FIR}E-mA+9-!j)C0gs3mZUid+QHgQhj+8fWD_1B{8GQ^DPWqpm<*q?!DR3JL+VB5YaelrLb|yxhJXkRL2OZX-x0C&1?0zn{Xp@ zA`@|1RowG!rJC`7EJdA=NjSuOHA4K`KibE8XE%?&YCpe|Uq}06_{2%N&0|VBBhNh; zwjeAO^k^0fx3yK@&@AKx-JcCTTRf@UK7@Q1lsuc97OWyMw7+8}QX{%$@ z1R-1V1e$dVkvKaEpg6D7&J@8k*9^ri#E>$AfAfslO+>KJ?7r7CErgtHGDg1*T!_s? zS4o+Y&*2L$#nF@ls-6``7@PR?I?>xwH#NiCJGtY0xi>9*@KyWy{Gt7Xk2NT(w@#-4 zonlv=x-T_e-QB0p0H2Gf(vqw;J+~|;Yn+m$=+dJ60w$U1EYTzfBy9T z?H})re;<9}UMGN`Z)nq|7w5Pf)UDx5vyiGBO?UtTSF4xo5dkOy+^3fo5&b6E*1sF;K`AySdKv6@xN6q`doA4SNE((bdX$saf?and$z!P`@fLV#n+m!yV-v7X# z>&~9^!I$mlXK(pGvG2W=Rxd6L8AiRlx3;@^2ThVWr*E}%4Api~XSPi14VIfByEVTKBa}T(W zs8juf4HVCp{}KUR0+2hGUK0Tu2ZMIxw$b#Bmw*!iEdmI2m#-56O&h!uFo`hbs*MI) z%R6qDLbHUc9SGUTx^&595SJGe0YQKAwZ-_f?c<-`ynAZ(-V*7-SM!(qj2QU5Yy~lr z_Bo}k*q$s8&U~yCPjcw7H?lwTGJSfT*Z&<>q0_=qu`t?Zy=|~Oq#Uq*|0R05f+)Vb^bH&XkY<16d+D9`!C$o3@kOsLbip!Pdpew5F?4kUK+VL!o2diAd^~?4AE?tbAIYg_zyWfsb!o>4N-fG%-*2t;Yz{0@td$Dp66El(eqg zf+Nm)F+O%Ub!I-pjnw8D>EIndaYkFjh7v-!?d2p?wuInXXSUbqTGp((bJT|MX10@m z@h$$}e}1dK^7(@0v9#?8 zqTY8oo}Fs;lt~(C9^9I}Eu$-Al!N1VnzgkWJEcfInK6*$d6i7OwuVVP<+IyfS?SUB z1_VP+#2jfZ%^hBClCwgnM9zL3X|qiwgAm>9)RBC0l%_#Z*hYW7z&xB#)0=nu{hvPFf3zQcIe+mZH}aMgHnA10d+5 z+dI_cS$1GCW-^O#U}s1q9wY>QEEw@b_ItTT$8C(x$M&ZL~qt$DgobXa(pobhh zaw}tVNF#}yOwKuU@&71 zz}Fk&uV|N07y%CzKJkUcmaELcS|{I7+8olm;BCV(ZI^Ty0a$;Hdp;D~+$a>^lt9|T zuAT_cdA4)AG5*z`et2{D1n<$8?e*<^-Wrc;t=n?XWQ*QIIbl9=~{Pehaz%8T(lD4+-H#TDwAxtmUFZzzKzZ~>&X?-RMAOh zQ1^1OM;U~g!bdVbO497aRfE}}`g2ULE$W!dcOlGrb7TL{>&8Bpc0SvB8&97;e|+=q z`#0y_NA`cw*YaEM;xkF`(HGGQmj+*}uPL3VJv`mkZ1IZ=*_3Tlu8J#eDRR!I< zNbguPFaCPTdSOgP7RzU8GcCMJ^32y)EtuY%Lgrs?*T~s2RqoX0Nn@|vf<&LG`&9^~ z@{MRHov|!c6u!1nw^bR~(w00V?#cbxsi~LKTbh3{s;4~jmUX#x+9d#9Yb(PpXF9U; zzVI_Q_xRubODF5;^GEw*e7tLtee_klt$Vz5v(8m7Q0gswk%C~{f(I3=q7kqzXY5vb zgF)wrsrM|(`b<0tP%*A^@0HqS&SzE0bi_#>4TfvG0_#krjg(wCIssqUc{}C(ihPAb|)54ThHRXFuiXAPYfxWquhO$!GBJPCg-v~d*wxaHKeS(4D`)3O%kNyD#sRt>!ugH(MwMC+gmr#fRXo zj|}X2q&0X1njJPjYcD8ISM-$U|C(1F5y`Ua?Hl=5>o1@0D$O2!*?yLN;`{o1Hw%Bq zDT0waf{yT>xpHb&hnkeWT3TthHq7dAWkFXmpCh>-*np5Ko+C%!&j3jwXlZC%%o!bpgNr(^#!57x0ky4xE^vXN3Ueq{gtF@hD;qV}A6fN&9 zmnwUX3s1Ntr&-SN)YG(Nui)W7eE$65DL#I@ z4|00+#k;8iynIh_z?ntv;mJ1b0cwb=U6q9m&qAY&orHe%!SkjhhYq!)fz4#iG*jnI zqFE%nuft(lUYt|v+!@pDYNVfO87*_O6mWqVx7@CoIy+0%Y(tFNnvYRv1Vex2D76a- z+m#PAM9}#?N-nJw#51M!%9#oHM5|eV(yro^0cI`SK4SP}phV8@D^33Dnp$?OqA98N zTP)0P-}w7?e|&oT=JVZ}-Gi^)tBB(BIc|=f4S^36S4J%1V&S4OZF9c3GYL>3?z!0; zOJ;4pbgq7qWJPi4xl$m9biaS&&WP?pT3SOgC7)QGIne!z&M%5cjJZ7H7?l2dCExzARYj&!s% zk_*$*VzJfQjuc%>({}K^-?r?2{pH<JTQ0Y!J2A2vs zrtGAEc#rFTWQr~|Rju!^hrsoy39|cO;xs2h*E*$8(d^EW(usI62m;O!%h+jsR6zcUT z2QrD&>NZYrdz961b5v!;FX1A!Ugl04Gxp&yr;W0-RK^?ZCE~=ZMAVy4@#njVs0UxR zZw(vzWVNx!6{X}|WW$+S1@awm7o)X7;gVoctSx#OwFZB?=qux5c{c5*>KRmDM8pBF zvi3Gg#jDDh^Dw%kV>WPQ)-AA;>BarEsv{qL-EJSx7gz`-5%qyOmESVpTBOH)t6uHI zybE7^rdAhoLpQl)!0}CET_(H@k$DigK5LI6^l18&DI`1gHQAw)TzcJ*XeOZ00nh}( z)~n9zY$JbEG|dRhqtmM~Ofq<_CWu*1F5m$slKRz(RHEG`mZ41)QpSUQzOkSX^@d%& zl9EH^Y-?h|?qIfU3>_!yg2b}O7T?~_fB6*tlj2+3< z4WA=j5N1RW;O`gqj(%m&AOL6vu9JO9W~9Z0^NfEiISq?p+q&b9io&;kXD`0js7Gp< z72+nF3Sd}sq%_-F16QuzCMArqLWu%>3fmshYE5UQa?V;w(}8RihvSZ+6T3mp%-c=} zzUI3VifF)I+0y{~ALc3T9iwG)+T^K99hm}#2m5xG(W~*_)}Q2bzk0T&f6c?tw|e@K z!qtD%w`y09zK*x5ZTYS|L%|)SV%EM>Nr&UF(Hi{psH0hEFS?Xz8%8LNyA$*+X~S#pVz#qy>5!nj(GBlS zaS9~eE-_QT09lm08pV{YGwoyB;xeA-LHa`bYp4|9E0QZRX`)2ABj;Kz&MU^d>?2F5 zJDRc)-jYlV45f;BnSE+naq2W570wnPnln#I(VAH4l20nTPaU&wrs_xLK}IP(bNf$` zxmU|Ot)Y%j@>E*`_ABSn-fnK^|H_vHBLSHWrI`NSKYe)r+28MfuZE9m4w~$-Z+FEh_=Xh1IlN83>VA)cF+qf=v7(q*~S|SDt7Y>|}(T5=d z+3r4F34J0pm+cc6>l&K`-3m7*A-!fTow6e*UFTc}WsBt1;qvCz*s6cOngTC0Pm4?_ zF0LiOb5;`@z}HIYx|_R5Cn40!+G+JMXn+gJ|K4z!ueSOjs|NuH+)-It`HJfH>$JcX(7LcooI4teV?$W?g0ZZmWo_?JXxA%IS&^G3}V6 zSe~zv%c}>JjUa#AQXoYj)z;>g&zkX31_~?J@_e#0_d|Qc>d)q7e z<%npj_pm*ba~`Hy8H+l!AHqx7-&6{4e#%``6?=ethT zfb8}-#hVxJ!%JIQd%b;7mwF=xGFOsL)N@2WMRZ4&9257PIT7fZ$KKVnVC*uQ#+Gd6 zt&L;#lo{TE6c&H2i)a%`>_dcjnugDEWLimU4S@Q)%{_yD>Q1C&n=)g0Wy4)LpbF0r>=lCaG);d>r|)(L>EvPnnRx1`*6CCZJf* z(1KAKqmH`jSd>SGq6}}TLp|RP>jT_dzFiv4)-IQ2+x&kthpe390F`TPD|<~3x@r6H zU1?*fFV)r8YI{2@M1tHLQIjT+##x+9T}f>)w@c9YN*{Tju{?S*S+;^S5MSe0nD@W` z^!fdV55&*z4IdtS>0Tk#zDD(-^-)y_<`#KW0tcl;Dex)wWfRhTR#!QBc3Kj}J8wlQ z!wI3=iZy?1BwY;?_S)go1y|TE#5&w?TKguK&c9@MlhpRmY29x3s%QeSqNFe{o1??J z>Ta#O*Q~~`H(%uM1o;G!%xDLMgh%wMJ?&Ws$-&|(?VPa)_%4>1$c*f0E7!@T_109B zy8B7vWMAp{t77c0zr5RT{2rL;(bw(gk7)lcz0800m8Ifx5;Z8llF?)B`$%h1XYFo7=O;1MO5cIhA@Sx}Z9*cK;N$3l4Dz<4dr zYI1*H8kx|oo!!!5=H7_;CzxJ#OD+B1{&X+D^5|=JyUraigCyXWlJ>Tl*wAW}WhEvU z^v=rM`*ta1N0G`qZ*!D1kOr@v=^l-vV@EH0>NMG@?bN$ai9pzxnSMm%o&>+)x)5WQ z=59zYUhPE1mbKy8afO@;#<0v$T8~zDR@i?kM?5sP!~zpcwd|Zx+8%gTr?M8@t5a~t zp;(3OW~ExZvvCW1GQMq_Gj)Y%w+eO3WOsDRzxvDjFZZWM55857X(-rjf~nft0G>U~<}3uQ+v3NFvoe+qiynWf zrHqjqT$Sroh4N-gRKRrSsVlo#X`KC5zhx2pl|cF*e9?aPh?ehi{u)S1M@~u|nv5yO zdq+I2DnbI@md~8DZe>6-rti`7l?rLTnY{Kxk9r{NIH+RT)TcRTU0}~B5qsHyb3>@u z`IWaE$Zyx)MjYU_aFJ8BQ7Gmf42pkx>dav-NJ@Ju9Up5uKB?YIOR)hkK@&Xl>^j&S zw8a$Hj8&xzh~FH>Htzawk2#^GnQ}f8wg~%IvEIF8xjlCK&4(}V{&LL)@3^TReC2LW z+g?^g377i9s}eP>nZS!=J&YO4EO}&aMqOi3ht(>r)H!Ru0@E|4S|J0tuapr#8yf5da1?WO__zS1DOEbEpQgedNo{_jJNv^jKj3^Pu6CAr&A*JW~7j!ZdG~*-Z)UxprqZM| zU&a%1wOCuKRFt4;O9eSIDLAa|v~O-RXMgkQPxo%?qc7U+!Im0Y@VAd*G=nSxaiYC+oXeCmG*oNLiFK%Mj*}uo-*ny?UPM9BS^nOUaSc z={Ce+cYPg%-lAZRoKk3R$9@_&UVg1?iiksLLpDS=Sr!1H9i5gsX;GUx<1dLF3tGWwN?{R87X^-h{r;3dNz8yTI!Pa;++S342xz4lc zx5vf9A|cr=K<>@#UnQU`c0DcAgb2{91oXFIW|~Mkq3z>N`c>sg^d2 zX?OljH@Eb^$DcpEe;4mQzp=MZ%lr@T&$+9qdhA8~Rx{PY*#Y*bWArMl94>suSRMID zCTroq6iheT3VOg*zzNCT(KFzI8erX;pWz7*jxL(9pJWf!WKPPi!)ki7VKch0d_l_gu z%#u{1QT=r}r4o(7tr>Mv$w!+>fMVP2cIF?x|7afP%iE`O_lbS*#d}?Ddrl+;oYq`d z?2&DGwAMJ(&7HB_*jILIB>{n5HPmPlqylCl>E3@T40ozY%H3y}wu^E$>B$ecahizV z)LbT|ft(9s`rPV@f&OK_`mTEAs59ku%8I!?^&%)xGGkI@xkH}L0(K=y%MNkM<;+S7 zmaJFr%c)tLfaYB_SpkV?V=4~nnUMx!%LKz+w^X_dg$HiU+X&0Q{AhoOrxQe2ey|T8 z;@*GZ>7y^yf#6l#72*o5dUu@bKLC&6+M`Wo3hD}L&PV|<|6mnTQYUzX)8-`D- zjXl-qGPG3}`j3VOd93iAPgl;sl4P^(o{x)y%?G@)x4**YnJi8&cxYo$pkFhMfLUJI zy^Wj>Qjxlc%9WTrsR22(Cs58?m302Lj0mR4m{`B_!_xGm05598Wa_+WS+CD;jx?450XWPgKcCn+eVsE^w42Z>M0t;&sR*L2Bf&N@WFB7KkT;S zW^=^>O;UX|->c4ML!)~??F8YB3CToN!wvx#!UOrh zR>MG&F1kafj=xhs)K;Wzq?+T^2ldyV;>SPUca1&xy4}joUk*(z>c%h#lL>#`8WM4; zyv~-oTh~(?Rh~RKelD#SOMQ4R6qpg*RXe54emZ=>)c|K~{yYo1dbP!iL^5?CAFJ)) z(P(3^r{RSqdgX8<26;U?oi*SFyh}A>M(@vbtw`rBX`E2)Y=A$p#?ai!TKc0@ku5{c0 zwUljhwz5icPr#u$3|gf~xZwSEpOZTPiMC)O+b%h9F;9 z+3Ed~iKEnYRxxS^vmbx!rsOJ3yv$}=3GMuqLa-iv*}nAw#r~d*a7=C^YT+fN27$UI zVF1zrrp+`4vvT3nzTm{L`0RLZldrzcC2+T`ZOj_`I+{*7cIOBSw*c=^mN1+=&CMxq zgY@_+OtzQR?aPm(!6&BfSs4V?rc{QB?Di&O+0kj35HplX>A8P)4_JMCVRtGGzhf=+ z46GuB*YBo@FlIfuD)lo$!DF)TErWk*;E#E&%J^{agzeE+?HdpWZ-jTWld8*lwsdV# z66#+meb*tH7l*TTMV3)B*5=t*o|h=ZppOMe3C}z{B?uohD>@@NGA*5H)XpHzYZi)J zg+uB#`E}ZDMLd5I(zL~iH^gR_b_f)$O3?iB3uo9?l2$s?(yo1p?X0Dyn${RcmZL8n zT}sb+huPYcJeBr|kPw-?wk$$0KeDGUxHHv}HQb(o|K`oRAL8Si&-Z2vkG^uRZs@Zq z10mJgz6<<33GX(V3(%};D=*sTSt^Uly+<@~(wgQ-!a;w=3}#-X!Q4Bhwk}N}717{a zaz`@)j!2J-w5gI6!0xG5Y*#9Vx94kv)#f~kGPd^9c2Nz1Vy0K9JfA*N%DImV6bpz3 zcDwp0yT%|#z?65@&01J%7bzgiV8r$0RDWkVW9J-lHped+OKVy+vh8#mQ2FOi@%h8Y z_n+TWZhL=!Zw~nA>vt0*dztZ$v@>>%2xj~&suSSJGuAv!%cxUYDM*KLugo~(#Aw!v zlr@5dzDQGg2UV)t&WmYB4zX4*UP9K10Sm>5*KwJHdOMSo&?@OwHD+LI(ra3jbCKrL zb7ekXdUKMLDk%@o=b)n+#Fh^lakl9-DIvnjaZ7)T=37VK0Kp)aoFQ%c6yxVn?TpnY zB{5xGdwvseT5g}yPoM4cmrr+zNRPg9ub$Jdyt1ydr>t|HteL~Q;(=F$-*iRGk>v~m z@4L3Ls>}wbK9_bPu8pZkWD1<;0;ic`pd;8%`U%drrHcCB(Sl(t%tp z&kOp44iemC^e2Oux@#>|-saX@zSTc|et-Sx-kdjgH=~cfdar;hU%l6Gy%^91|wxtmz7LKaNQqywQxh%D5 z9Ss?YrmX6TgvIOCN_W+n%TYDy=qBi2PtQ4Tku!_z{_LdOR99j`6Fmz*BSQKq_$bQi zUK6V)jF-)2hF0ap3^S|o;wM8gX^mHdO$lSYMAig;(YGm7> zhh&P*0Tq9EnNnksQL-w{Dmlw8bC-Wu9DAp^YM-lP#;&Y1Vl%&)t@drT<8$QBf_;@a zm^K4DObpnHp1x{602NMJ)5o8 zfnf88$=a6QL<7StJw_L|Mk_f>8}Kn^ytg>t#kuodktE&C-1y+)z!-EQFLWH z(u@V3?F1~iAL5N=>xh58>f}tb+R-etjwRNMBmvW3GoTR~o`dtS#y&Ad2mF;|vwm+a zbBtE)b~LzhI%pdmE}PaArkmR~OLyjctt$eWbJ(@p9+hv|227q;H>tWHU9)nWq+6(y zXD4&8j`mgZZmllSdd^|10ek+M@sK#FHeOc2|M8m-?^zgqdcl9M{Mz5Yz0U@H^aZ?4 zIHa$qGCs9TOl{f5(T?iJlviIGT57SWGg)lJ+Fh$+te(kAi0b2Qa) z5jTC#UDj;I8AU$@&`($gdP5l5PKGejZ&$*xQp#graK5Wy3mgn=5c|4*Rl2;B-|PoJ zL{8dqzpK<@t`~o@yoyS1RlQV#Or@X7{1BMS$kXU*3dnXDE6&_WX2r;Z^h2og`h<9~ zvgRQ<)itk#346lDmU-?5TCHrOx1&*N(YAAwL&4$Hi1vS~UV%z@r`pfXXT^ze9S)b& z_Zmx10%yFf#&waqemStH5O>%1UqUv&f)K`+7IKnP7&@VkGvpVwde`}co%bMJmW`ntU)>O3F4 zEwGt3!J7~$KDZ7SOa7kd1zhh2S*!L?q!Li(JMsnVtFq%CVL7^xv)JwAJao(kL#~2F z)stIGL;E?LN%z2s)jje3FWp0L&r`efEJQWN;H`@fu3Z|hjrh-2?--(Xms+Zj@Lj2S z+c|$%J;Gt5qA;+19YD7-JcylX;EL)kADBfpsVnW(8a8Z49=^P1t+n5#@qc?&+@8Mi zj6V9>-M)d#*FEbz6+%S9HCximT^6J$G3xg~CB`h)RFf~fFXMXhbCNOAR9H=wt6Jy8 z{k&vub(CgpEA&L%@i|C;&6bMz>5AVy+w^}$$+z6Tff19Iv(p)RmRER?qmhbS^kv3k zA3$0+0P{7YZ2~H#HYcsUsBTvN|IS*fTW7H2MM!NzCp?x9)Nbn>(z1l#yIt@LS<)rn zKBIqo_M3a((??&mTUCAi`aMl!m!7B7?vuJ^Ik`plQMd?GL6sPz9j#SU?K|;_n6!WJ zLsqq(dnAsYbDx#C^_ke751cVe=^V1f?iqHMPl3QYSpQj9iSOtrpM zun7(?>GVhg{ZmL*A+(e_TUhxkgK@ux+%jb&6vr8v^8T;*u9iQveFbmRlj<;+@3Io)n* zQuh`|vcz7x)w?-krr1S@^O%V!T|unj$9uxd(!|o9beBNo?pPS5=+h% zkoh(ZYACwm^C}~4ODWmtfK`XgEXii-JtB=#&Sd)5V``nC;L3@zFY5rd0@>*r{j9RA zN|d>_AKkHPUtz9iawh(Yz%6eT*o; zk4qxyHF9l}8ZYhCWO77Hom6vn>8Hzy)+P#{2BV1Ll5^mmoBTvDyK{ek_sppSQ%6hH z?;W>3_*&jVL+eY8yr&}YzzAh>Y?U;5=@dZ)oPxHFv%SWGR6)v>*=K*w64%2MYh^L7 zw!MNX9Y@CD;#-_rSM5wdmZFyJ{v-O*FO9>M$=~jBF zO@3k#{#|@pU*5dkFYkY6d-La~4CzsRS)|PrEZ3Fgjv>17p zi^6XzS70&p@M%HSFe}XP>A~-`l;oR9LO;Auqd*RsW9Ot&FmrG}OiJ`~cHVi^-gD0x z3Jr(@xy`)vM9EXv@Tvf1K$^d~uM~3%*xV%8&qwousE`uM$k|v^u6c5Q3T+saS3#s) zZ0l*NbLpPZ8TO6A`|{*NVyP@f$Uc#=ww-VjM~fUa|5Smyy|w>j@Ak*{Z}vBh$dA5^ z-@3i0j5xFgvaFP8+K-&K_si7_9oJdoVU(|ey=?j!k~&A3$Bkpsoc$!s!_5)Jn3Zky z?3k%(wth&$a#Dqu4=^u(E7vo36T(Zcoc675vzoffTBp`5W|I99*_oHJjt?0};9wgl zR-z@*+OfrWwax0Z8)jZ|IZH&~NKBOylPOf>`u|b)X3Lu8NP3+aMRv0XPNHaekcC){e{~`#Tj5N7?kVMD2i+`Vx{X-NW`!8r;x3Lc zmCu>%qNa>WF6mN_&i~Qo{=@q&^G{yHk2V+6+@+h)IwOYrs^8Y&rKZmHuwdr&0;ZmS zUeSHCIuaif+v{j==b7x1LGyS_>I($0c4Uj9D&;2qV5zcy!s_nDc9U|N4~!mf&@I}r zZkaL+xUw8L^{U`Uc*YLyFGAUNQtxhPku)|hs z+i!1k(t~2ep`zVFSW#D$-Bt~i9>;ehflXQGWO2e_LN3Q>(3DO9YZ-u(>yQPVffFVB z+`3)U^GGV+R54odp5{YZ#H3x#y}dv4$Hq^$kER8SK+ihcA_Fv-Cf}JE4M1b{vqTZY`O!&@) zUsq7e@*rI?E8Lmu($@3YRc`AEeZ%hv4lxIvOl4Z_&hyb_=x=`8-uIu~&tAk2pWUjf zR-JR+5ZTpJ44jN_m=;Tf@%O$5XxBrD=i8ri4trd`0}P)od<3@BS3OOG!TCWlZTAa* zVtM!GnH4f9(@nT75)b7vd2Q9^hB1$=QSX+ut=Qb9$qFYv4GOP0^N*X+D>ks*!yKAT z#Mc=B2C5~o1}R`y{cc7~?J!~4wN#27MPZxQcKXzk>CL@+ZTZoA`EP#z<%d7~!^cnV zCokfMPcDp%Hk-Cw`!V>Ui=K5>Lwj_8fh_=5EXSqqwsdh5-!-o_AgbGST=XQo3%fO2 zV+KHb#F;)vx}1fc5xz3B3(+ufcQAX9CyF(Zvs7`L3Rs=9<82v_bR*2IywWpK+zk3R=PD~UqY13a&j>5 zSksuELWsF+;%3Jpjo@3g8AdH_-bZ~*7Imy_?G0$aDMHv{EVbTz0Dyb-gC97L7N35` z+H^L@MBgQh_eNHez0MWddEtbA+4870nNK4k#_h&0h1qtyox5eb9C zt6Il^?O2RMOYeKhBSjo{%!^yD4hm2*Y$!^cWjopLhI%y=dPvTtO#gRxOBla{PBms|KOARxy$(Bqe~6GQP$~uEOmZ9r=6jgMh_n2C^vVV5oIvu z-RBi?*~3U2avYqkA(y{@;KMAo)lP#u<5s4_8RQ*NB#)f6i~%b=S_GrVk=LuxVsg0D zIAvu`%03%500s=P-9X_~kq4ix-I-m+Eo^rI1TUwxK0QHz=2%+mjYhcs77Rrh*Y+(p zP}+{Jd$caIJ$QA3$b8C3FApY4q&Jbvo$mec6I`jp}*iOXe%JctO%kM1F=FpG6y1yQ&K58F)_9A|?xh6#Fqjm;{+7ZXa zviKm4lu63DtkKl)PUdYzAw4`8p|LG=9IVX&q|j^IyDt9pi_lK?fvX!{Aha*HQSqy6iHOva1sOQ(_Lyh<0yL zJc&~r&Ki?cXK~l@f`-8dFvY&twq=i;+-{6H+1hdn)R8~`?0#*lyk}Yd>_z-&bGyS6 zpI{rb&O&BvR$x&XvC-h#XqenbIdT2YY3EGH`KV}r)XurFo6?Qkaq6+Y&a7Ow%dXrL zrZOu0@SB}MQa?=aPiV2FroFzH=VgC3K5UmnPgN%%@BS3j>9(9kojzvI+U*?9MNFRp z5f}B7quzBntklvln2lb$H$|FCkC68vorrE@6R`Vsml?Wz)^f+6zYe`$#`x?d{P3F_ z5H(?cpP~XdBf9SuxPh>r@&l0ymhNutejUy6sNm~VskaYmKbFg97L9#J+-#U)0OvFM z3V5vfg27)#k#<(^LOTp1$7pZ3YgT20GrXC5pQt^oFNlXVcI$LATlGSTrq10;a&KrC zF&E(N6d^5I@oYf(KOueS#B{(rJa^<8m+r%V*oizyeMph!ws@5DqpkhhAL5rkSAqQO zRs3jo@1zhU6HV<1X8YQ`OYh1q`{AS#Z8}(IchoJOowmfIqF$9Bn>+2f&T^5U74fQ@ z4#qC&m-uBVhF`uF{>Q`Rl%d4PWTm~?-P_XV&a%Kd#GX>f1rnm+NbDmOz{gca+7<(U z=X!IU63o|N;}$?qU}s9FBKwJ;sytG9K=4Cr`6 z-THhAIc4BA;9wcx@2kyoB&R4bbCTR^KO9-oG`>|Bg3P+HSCwYF!#kr1Q_e>Rsvm!f zAO75<``OF*(f01@Cs4Q74bVXne)XDD%3`b-wdT>D_u9?t!{;I%Va~MM^TV`%I$Nh; z8nVd*+4i$4Q_E!y?be~a7`X0Sk2SILMubB;_bG2ifpYChfuS_?$g}{t;LYB9jUahm zXAhmqR7s&a330slBGqHf$f)erBoN8>>u@e!8D-atL6T9;GWOa?bNSi=t?b3m>4qNIzR%QKA*5qv&yN)}0PEFgrQ+=JKCDvoTpdUMO%V@8gOJ56F!M+IiS^>>sl;%-_ zmR9=OlN%#V&nOP7cXfgc3^H2V7reLe`&bf#oA8+9Li)x6Fr^eS=%j#uXDj{ESL}>h zr!6#{ALTLr>gykV`0?upTl?8d_+bsQ_tDzkeW}Y_gMe+y=^)u_Jf-(C9%#?GmmV_t z7oUuuAI2Rj{A7Ybexs3FYR#BGBfCebpv*>5T-H4}*L3VY+8XPr#J2IewHVWJhJO== z&zN_g(q=EE7X{*~E&DZpz(T$Ve#bY_LD#}Fa`aS!N`s4tk5;SSQ=4gG(}6ErqH*&t z5Hd4rPk7|k9wg~1AKi2R=8s=~X!3CwDk_26{R3dK=6+L^FO}63Q2Jm^#T5%`prR&jRu4}>5SC*ZBXwy|T(*&!U?<%iR z8#uy?iK|Y1_Rbj>EhdrRog6)NR%R+%9x$+bK!;-L3#W--+T7i^2ZEs~pqh?~^laFY zP(M@|U^UeWDii{j*Za7`QgqIbDv*EuZF4_p9(?v1e)vuX*bUUMZcOyGIWhWmNzMh4^|{$BW*pweam(GqgDT(4OnNYGq}vr{fENuu6N*00_06Wv`R zAjOTSXA-(Ow_+O`wofV9T>}5^F`FO8sQ&8P-hS{-{^TWp{Ag>3GMnAtL=@`)Tqi~N zMp4tOo(LyDSOdb^@ikjOgNbqpRdZqK#_({HiDtpMeT{;C_BN_z7u@@j*!04d0Fp{fc5FVLSVA`s3&3WsoCs=PA986SqA4dJCgsBHp4Jb2p)S&V!*Kb8UKb ztS+=$j%?{9Od3Fy5)~b#{>?SKQ?pS@sBso>~d19Qnbs^ z@F_mRIFt2OQlUflH2%fb2NI{DxvBJR|CS>^1;m7c@pzytKsu(pl5ax?8ddBiTv|Rl|Fgp-aez>_%oO3s5LH0%AO1yk68&dtkPVz`;LUW z#DP7AqwNemm@_m;Mz?u~?PiThDz9tc3%7B|aE7m)=iFnvbt|P{7oqOH)E9B#Ew9gL zuL>Hd=5Q(ffvTUGlXK4usdJ7qi#5}KKui3@@gF04o8}tvWlp2d$H+f>jW8Jy-t73yySRkr%!2H z?#)fwLYcT~o^@SZ%Al_&Z|hvO*%+a6UvXc5`H%bezyI>}UH{4_FWg74@e2!?Oqoq0 z*_EhZLxXqLT?b27g*Cc1JpJx}`&6ykRkw=5f5tn#M^|O)fu(C@@~Y>}B7K;4AB-1U zZ|xhVcQX79UPP?FnWbKp0-4GwSJ&AmnWZ@B1$){oYaR2u9$e;xEMIO@Cby~$BZ#y% zBQwKpmtL$>tliOsF{x83eKfHH;Ci?7U`v?ow zrX6s^_BC_xt93du`-s)0S`^Je`&`u17{?7bjr;DY_~%|L0oHePIdX zzm?6Uw3@Sh6RZH^@K9NQ7~Ug!Dt(nRH{H1otEZRdQMw``Di;COM_8!8ihuC<>6b4* zzGuGr>@|GL4w7H*FT2@Y_v9VgbF^O8x&}c30)$cJNO+vp`6$d=Xe109Hb<2nqP3sR z%;Ccr9tj(=9;XJv33C@OCn6TW?-gxH&M+{wjn49$(@~dZgL46YvFvf(7Zi0FRL`on zM<`z=FRrqgm!8vmD26j?t9940mAJpkUbdfGUX5*7Gm36K{KfX_%G}%D``ftmsiRx( zYrnpG|5N<@^N&A&_w|?U|K+=%_RnAA=kMO-Re$y}zC{WB`sfO_;L;nT%DV2Y+NJIL zj5f6al4%9@pF1Icz(@@N$CcP_v_TFm-U#l@7O@w~s@$s=GV&3ZH)RQ`pjR=-;3EP3 zp4WC!S+8BXE&}(N0$jgOWvym#>-W|;OZ;$TZe*N-)!-Zq<^Y8xf+vEE$zPz`w zpS^&ux0>H@C3r^YYMHdwnmmEXndy6{>Fl=qOyFr`X5m-GERCU}Cp-9@&4GS^-R(mT zK^2_RE7y4%VG-YG|FULr2y{a{;LLA3w%%(P%|AE-#ltBU09 zk@S(`oy^F8_Yg(`0LT|YgWVB~bxP%}9809W<8VNFu*c2of)?CsU%6TXpeAL`SDw(n z{rZQWe){p}U%r0#Fc?4Zw0!3Jy&x>gpUzHrsO~&tAJ-lV#zRJq!^NqO3JvtsTg#Tz zX&Wk{c3v2*3BwW`R2X`L0pm7n+3oQy+?{5vlyRbeXsc(pd-O4!*4(ZAR;I_dLzlYeDHRxATpC?@9gag?me@{`D|?W+ZR`if4BFV9ik_$Z7QXu?qB};N96~2$u}Zcqw8T^zFjhy@w z`j$89Is%wF-A=YrjMyMv)HAjWPOcS(6m8f`CWyYO?YZSLz)_3RrmDT(8R`5frq@OL zGMk4Dy;quuGoZU1Mp&pwEVDtnn3I35X-Tlpm(1MrA}fc4g_RT z;*4oz&`s&@WW`HA)CtBRidm;N{0|%D^~&DHX%qAVR4=_UybM_bZvrzOfk0v&s2`Vq z!Bv~ZipvQ@eXW%@SeR5VW2Z|^tWy$e&e|2-a?Do%*njjNfA}SS_~pC%*KJD3N>Cf4H87kQLfNjW!Th`k;F;lsY~(JT zvS+gnAx-ZVdjxH?&mqh-@f0OS{KwpKWV@_(_x!;XLGi z===qov+>%hp>(R3C%zij&4aobkBOn1f#ssj4aWu}tjtv0*((L(Q%4zxK{ndx<<%GP z@4xXhzx(>-?|<08{NY^+<7cnn+uP2!O4FRz%G#(`<;r@nx%ZypV~b{%wT(=F_JU;9 z#u`tL8dAj3)tWiLrOwf9+`j#mTA%uLlb(`&qL`L->1p_=0>4=YBzCE{m$6=NJO6A* zsh_=WuT;(X>wfm^9R>vMcYTsslyQN(@Hm5NYgh`pRn2se# zv9FWm=1`|b3b0>mu17eGG=}_t=R;8|!e>&}vDeCk5V0GmnnzvqwJjl#YhP{mVAQ1) z5MK&Cl;iD?x@PuSR%bvamUWtwt@chcQaLA$L7-^%x!S!QP?n^en}e|9rS-o&S zNvZ$p#`(j0o|eyEw%0<_Z{COFv-vIn?Ph>H!Lo2v1}cOn0(2*qkb!-FWR;eMB@-rx z`1fa#I(#2K5fzV7*#j8NT%@kE4zbp2%%OP#AM;#waX8(@8T@{2rsnKMlZ+boIvf3@ z+qY;I?9sy2oMAb#vYAz#Fj7RjrS2PWW`@$MIt{d{&udLMObu9CTB~{0KtbPdWE^Ax zb$0#MS3mi>oqrWS0Ob3B!_V&x)qVETeRTRQ&B!a3(BK80YmKsoEq6~T=kA&Iv=L-U zU$Bd0?w%53GYzu~SV3R`E?VSp%_z1tCZ_j^FX!6qqd>r?7-~&~JC=@O8AEowF=hS(@B`>PDM=`R)s@hY3cs zA;YOnp4IkT*3oZqSh5UxbNY?1zJH4Ee)r4w?``U5FW%b&(yzi_zSz51xp(ytxxjO* zPb84Av*6jB;GY5rF4P3oRNmvwjaMPja*UmfOAIND?VhSp3ElQYwtI>Lx~gh4N)S_< zp50@by}{phkIYhkcVkHKrbt*FvEb&oH7;<4Z%mfr476^5UlUVrH(Hk$WoWaayIKYhv%}R3VMg`b^te!EOE5{VG)0m==%>A(Q zQf6o^C6EDmuby{~H|;koBVyFLR%wIO$2$A23($_UE&RjYtc2b%x9r-ir7SIVv}`TL z9vcfbuKJ1y)+d7>b>OZac`bdGNTM)Jl45n|}>;q$h{JH^!ZQbl2AB%;^_TJI{UV?XEJZ1MvO| zf=VmJDa*~OabNwg|Ka=i`S0Vq|F)a&ZtW*8;fGbp*{y7on2{$=e`_Y+J@SzR$IJg zerZ+roTCQ!E4jpQyZzVwS>hSn~{>%6A9XjXt_VlyY?xSod3OD8N+#|L$FAFw1 z){olCJ&es~<1{B(50e4AV_~HddsmjFQ5Ws((QX;b?`YMX-e<9H3}Iqq8=Hhz(cUWb zI5#;cBVFb7pfu`|${4867SEHK942HCDm<-E*<%#guk*SEV2ioN9_h$SYNPoSOs7#43q?79Q#?anp-l;Q47;cC!I^5lkY4XS&)lO-U_OgkxL7a< z3lZm4(~2iDtUJugfrx7La?XN~HywN6Eq6lTZ^vU4iPLaP5+1b~q-bNUK40%LKmOqF z6$C$f)jl$ZMq0m|nazoMP-$kwY;UquSyuC>K@A&8%d}pw$0TPkxn~)F*>Pg2fm$N! zBHOhI;Uw^lzGw4RBgeX4=V6VB#%`pPoRB5i0s&>a~(~atvZC?!k%>7&vx3?#; zS>zURFoo!cIE!8vztsRg2E%w*F_O4k#njrKu}lX5@jB3`2-|W)pbB_*XTaJX<3XR) zg$fFB%LKp0K*>3C8~&0y1c3OEC{j61oFhHzel+$C%pB(OPH>5Tqh#pPXBfTM^bWn& z3-c(iAJU(G{_!9F@wnF+-XMbYKCk&+2xPQewSg5d z7-g9Sl?|ZCC-v{E2P1(vR?jVfH=bXTYc?tLwF-BM%X#1s$?R=afdpNOT-R6FfArjz zSC4`iHQm@U=fX>W4QF?o?=hxbB=aW$oBG&&o*r4WMa|r_v1IKy(=X6DD?$h!Y96O3 zh#^H8e&pjest2=bqYCBW*LUu}_;3lZ zyJ<~b`%PelDez<*HP+NNdqM!%eIMRp(%VfrW1exEj&OpZ;#JV}!LYK)y&rv+Avn)@ z*B$q)r_#@RJ1Ge`v)EAS%A|sqSh9MR6Ek1uEB^LbwT}Z1pS^k?c1mwndq_V*%?c>g zHwxgWOWV|c-KzMsx#IFuo4nd)Yg5kxK|biy_5>cd9=|n(t)q0qE>(Ac1qeDB7ixO5 zB%anq&r=Hj&6^MDs+faz4U>X3vn>dfb6pu&R(iA*xf)@dyUM8}B9EPUtWYj`@+x&- z=GLONaruw-jyN~GMimW1p<0g|s&#a(`;4&BRPXD5{pBxy{_zjLyt|*Dy>1@`R+eNi zgL&?`R6f+DATIPmT@wFr3#I_*@J(p*0=d|H&SFx=l~_7w^a`Xxt=B4T1$E9f$!5&e zj_F1&wJfxh9D5vUxxQgkyrz&C#%p~N+o88S4bYBD%C!X!qA%QJYxbJwf=MVdjFyX( z8rfHW-*uwEj(VFlr+O&d4n-yPdeWcN$qk+E=pYN7eLh1MyXxz~=wE(~AKtsPeDRG8w)$;-@ zRYqlo2Pq&;zN*BRfnV+Y1ZEO+(Aeem13GknJ?FZZd2VoUOcsZ`IE0Q8Z7&B-(?}@n z3Yn#+wr|k~x2kpXo#EzEN_@MduLBl;`!#<4 zuR&`2moM+>%RYPcK6*xBHu|XCSo`1I@x!KUXQz4-=z zjK-xpHi|K;yzB0U6Lq=XbMlzeOp`(mpvYOT4w7}fbC!Rt@mgBU(M~LAenp*Ua!_oU zn2qU4R56##a5T&3?m&NyA`9)Ub(ji-CtXOYnQmQkY!2SqrBI&-=|r1gJEPAsKaF@cgVkd ztmVZun%8SRo+iT1NY{3lL5iN|ZX*XY$5yIbl((g4JPOvr2MiY3P~4=+PAgU6zrUK(Q)p7&4mP~ zEXL@a%LZh+t-h?hNooHj1;Fp#jop9t!hN)%5Ff}pr^D91s)y@p6I^}TzInlnMfxI0+HULtu|&4iZIp5@G)U`c`|g~-ir2nhu1P7<>wpK_VhwE zD0bmL!pWV58gCa#*OM`v>v7VqUq9xlJ@g70y`O| z@b?dKKQ|hW>7|x6_P+hhI4j|*y3D5ZrdQRu5KttkGVctC@~JL=V@r`UUoWJ8>D#ye z?!BV!XD{5#Ow9VzTi146-cILwZ6mVPL>I!SeZSjgwRxwI?jNREhL^3#opwMqFT8UQ zbgW$|b;$08A%Hv3+zUX z@LRm>=>PIGzn@M0?rVI%fB5B#zxPf3>{Wa_Ui|AfbpZ`3orv9;ZqX%_V{=nl8+})k z3)``K;REg{DPtzhTqA|WIEs0UA>^n=;zAZG9ch<5xI7boSgklzO>V8JmTcZx6?XV^4wTcVTNV6`7o1d3*ry$&6-lILZ)*fN% zb(rlg@=5`q8+wfpv+G{i2!KA-y+D{r$u)9QWSTC`YW7E)jVxw`p4r#zw{?0IKs3Ot zr`H1a4P`~cU@ZtiS7;r#MFZ%;-(E!U2bRBL3;yu&%ELX8pXtrmLp}%a|*DdhpA1VsQ_LpJ1PCo{H(=A(w`dMM338V)YfW|+b1miac6(6K>YO&@%KOe@@4<>{*3r1uiZ!UiJB{f z-^8w&&6(ic8~?=fK}P+3ugwAV(v=$`V|DIR0Qq4VZ+l5M@*d2DEts_KW6b+>cHvd@`eB{N_JcKlvU)Utn?FY`Ip-N@h*_c!Af#4SeY6sH6Ph41 z|E5Lr_2)0|WgI?v)m|>G|1AN3I-8au_e_ZjDSFY2tgWB9``r*j_HF^v`y!RtfJhbi zdpJb@sAU_`)rvYghREhNf(>ik#q1>C``!7&@0iI^WRTYE{LN2&t^NKp`j&q7%Dw%T z{^~;SR^9fdgcfj`nB}ldPo&LbUPu5i+qrbid%HE_K94O`fT_+}lMI!AW#=O>#&pJ( zXJ}iVQ|cx%O+oa;n0}(%HM((}gFOBk6&$@VHh(%~Q()z1OHn|N?(Rd(bb!U8c z{*d`@WBjuh@3&3;D>ik1{3+*9dJW-%Jc|Xf=3eK`o~&V2IBr_JJ?4)o@Mxp7F&G(S zcxxp;tGPP3;q1Zn_*RqY3;RB(j%Ub^;Tx87|<``Sht#IVI<Xq4*3We4a?-*NZ?jt7C>tIXD`HFx@=(oHD&n#_Lo(19&cuTDi@ zR7bs8Fm;vLJ5l+84Cc*P;$J?Q`}-c~^|Kf5rsUMN$sY+3^Stx&b+~G0%A^^`b(V{(Kx=mjqaG{>g--Ufh z-^r=Fg=N~RrQo@`eZHyWBQPwKTyTHWE;Btr;L4&*X_$jKM`{Rg<+Yx;a~x|ovbB{6 zzIb5A9b^0Ga+g9jxzZI+8rN1In!x<*4lJy#pdgQboLXLMf`9SHpZ8Bcy?1B%>~;HX zJO9ZNcgyXeO@(84(n}1qCG^o!9eiTT5~L)_GgWQ$%%ImJmC&X1Ba;#=3rq z@m4o~M#bt{r*XhJG8po<+V^@m+OtC#5~=-QIHd879b7DpK-0}G2KHhO5iihw-(--! z-1yFaw}1HIT?z7Muii(=GVQb7eWDE`S@GBacT0XaOwT`aWV}609=-`t8`WJm3d6kW zqLvWe@2b~#JF}XP$1hp$Ib>=2Oxo8nIKXg!&_`>VRTs>y*XHS7$VU3w2kwEaTUsA9 zp@MIx4Xe!T_w6BquyA_Ci&b(0)Sljm88o{CGD1D%zBKAd?=(@LhH@F;&gxw=cUfC1 z`nU2RBWt|u>R;uLKmT$6eBYgL`s}6qC$HS{r&L*Gq|v6GK2EBwa`^q@-ZtH)4BK~q zuf{hbCMM-|kItlEq5IqdH1)V*&mwRz!mHZ@Bl>oWOkTn82LRYhf2qm*K`*ahb%bI3e| zONb*0R6bg7vCD-^FU_>TXm@Y=W=Fq&{KW9Y-~He39dti?>0Umf>(`H{9OK7srM2Qq zE=7zEx)RPn;uAdlxTYeJy=Y54-w3&;;AH>c+J#XHMDK#xv4?8WG|T zpPZ0EGs(%(O$9sTT;ds{2| zb{DP1nWRFsqrOW&{>1FG6;cI~r5O|OFbzkC5TyOa8sajmGdA$dQtjHSK{nocsaTGR z;$zt!(F~i>=vV`;?vrK+8+t8&$kyM?3V%bYwsxut(*}~*QKw(o+Dk>B7^6Z%KPY|j z#+k)^+`-Gt#XS`%J--RAnD;bFxd<0W<$3@eV9rrC(Lj9klWCg`hwk3jo6FyPANR|C z2EgB|6@B*NeRMc#WgY|!E~_2~tvP17^?6~GDN|C%3aK%Ft=4BMK$BNJ zBiT_WO?$IMPU<;hrFOdva$}7)&I4iqUV@G!*?bS}1qbNBtn|rzH^4zUCoszxo>CrQwsYB#^ z^barB(Vu_*4no;`*U?XZUb(kDmv8OSKC?;`;-~XKd1zIvKKv)q);MFA7-P8+eqVX@ zy6Av+(T}cWgPPinrem!JON#&nSfTA&msLCsl8g^j+4U(^@6lx(W1Q>FbZM^)Lma~O zu!^9@$ZR#?z5{i;BuO~O*df3@$9beuZ5-u)SGiuR;HG`FIc3GHOY`}b_s7aJ3nIX@+z%=wdR=tk_w;$^x>qk9 zo^w`n9d$hazhyM^{Ggr<38<=PfK3?v0Edozn5Jbh3GsS$8O;f}Ru3{LQ)S108SOOp^Lj{Pa=>Jmj>vO$oKV$_F;AQHsEI@7%@gxdqqibKep34EQZ^aD zC5|B0%tpU1rA#@z?KYZ+iFkBnpUQbyXxQoL4b$k57PY;zzyJQ9?C<;9)6ZVTk9PN# zTeMLU=j5ph^m%Er8nSvBcJk^#G<#=ptq|34K}+|4bIV!W+)MAzG=oBc+cF52JZJd* zz`%0$sm$56jcoV$I%>BzmHDQ4KS-d|-R|g&RQn+vxe4#800YfIdC=CrOY}y7iNct5 zBJZ&^)T%HWBg_RekvqE5)v!^v>jtt}wk96Kdv0aec;B_qauF;&@9ggX@ojg1|KM{U1HWpS_+h)rjA^;+i)YmM5E7AWYW;)WQfhlMde7vwV?btfmKe?l;S>+)*y? z4oUvhJJl#rw!)mO*5+&4kRB%)qLnOXHd)^GdGxP$-~xXGb125_VGAubV=&of^z>_~ zy&(>`nWG+J?56<u-4_=gW4<K^Jq{Z2{=QDZNOH^c~2es#RVt2G&urysIO(e?)DNnaN z=)A1>z0MHA%GdP%ZgZ5IKGaVdMzr0ydGw^_R978O|GURtm*|~Z?cQa&mgv+rN@}Nm zljG6Q*G0V6Dr&Tl+vsEOI58T36C6lO@r9wwWV*QI|KBJ1Yg^?X-aA@<@^XIgB=eri zGUu5yH!8iXdY0HZ*F$yDg=xBTwx#FnfGXT!JR%T*>l&F17M!u>jnhXKgdAuJ?Fi7p zhOr^{kX}!vhpCHFL+c6_OoXL{_UNR#n2YRXxEV?a=;QQL%$ zJhB-(hh%8&VQ1Jn^)^7Up>_36#cRl=JfKmAn#C~)l1)4s=lDN0Xa9#!^84T9&tA+A z_L#wT$+K1!m95C6TTYGXgimr0`vqt@4nM z;8x%(Y_l{#e}kL{z^Y7tOo!F|^=(bze@}#7Im^7p#VJltv%9tKDPzf$TTkTJvxD)h zi~+mY4bR0;PIlgG4X90?kq4aJj=8d~zK(dk-boEc(~NWA=ZVUL647_|`2TumkH7!J z*WZ79QU2s5{a~kK>)g=mb4Dh52!3Y@>Z`VX_ed?Hhqvsj?znb;$@sFNGKBnr9%@g5K~NQsi&hA!M}1*ahh0mbczo^RyXv zFS-kSQRlc&GG;->q@<-9WB)zM?%vko{>Gz+1=+9ozkIrATRG1HCZ~z`{Y8Bs8+MQg^4N@(-CSL`N5b4RXx|J2z zFs0Jd+K!{I^lL~g#768@Eg{yWs@|CdW4TP|q$RdujGn!CyjG*BBGk<3l{~e8$1^nr zr(7Ra8UWd{v)q|oOEJ|lF5$INX)m=MHQGf&u`kDxGDir?~|NK4Dl->j^3p zmu;!VX6^5NoBzXa`~2rl*Pp$N9~DHzr(Y^6BkF2a8ba_g7vxWqu-M=j_j4W`VU4Sa zFH=3IrU>CW%ZIXg!p>4=jeYk!_AaFoMQXbev%Q3#+#C*Kol#emXa8Nj6 zKsg6<(dj&YzIq7%7121c$u5#S_;=cNilX9fV~y8JE?U6&D>IGj*MS+z*4 zW&w7aq0EN=iP5jy-g}Jy-OKjAcXj&YMf_-U1EO2K6@-w9lm$DrhMuH9sb!ZlHGs?A zh34U5XNX>dHS=L@uTgnN4>Wa2e{YBd`1kE1C1`q^=Fr+ zSj^~u5g5>eC|u!Yv2k}{WT=lb=+I_Jl58Tea7U4nd#=8?f7bB~`(pYVJ?vy3hy?t+ zrl?@Iw!D4UEagMiu*O>60uci%2wWJr>1>T5(rlSDo=%i<*MynX`a=ITiO5yB zUg5NkgwX3M-D2-^@eEC1S9}EXPyU4upWXL=Kf9m3h#ze(ba)G|dmiB!my1Clk80`w zOS&$u*P98jGYI{}flH09k^=)h3-Di=s4UPk*NUT;T$!<^_9G7*pwYK$M2V4>-o(#`Uqjw(_jBUez zcS(XGq!YWR<kvqb)v04%l=76hC~N z#^UEiz^^pb*mWIm;8HUYNp-SFFh#F1epHDnww6*EF3jeLh_A|-YszlcCkNkpH4pvy zE>L&(_I~#{Jzmqw*oZH>HC4sUwHvK}ehNYd@x~l`nZ>SS?$*+$ccHLRY(So?{xJQ0 z#%AgRW7llA?(w7n`e|}+GILXlkrG!hPuy0d?9Dm#y)FKauUq{7GyK^L`Qi7suaiKK zPoHIG^R~5S@d(+sui5;RwuaM^FOZ#Cmh(U~koO>0lx%IRoAWHj&+Ayoz@^TA2Vz@JClF@R7doS(kyKKtA?Ilk|*5nwXB&P^U2$awR1&NBeAd!j5lc&UTa$kgMWRkFvs;+e=kKBV_rpY zAz;&0Wsd)ky0=@lGda%m!V@CLq$G+`jIA@rgy(oODzmb(s(hp?aYX)AH%K%9W1~e< zG2xrAeZP+P1JGozwYTPQ2?t{601fP2-(OYco6plnKOl$JgnMLQP|g!1G~c3d9ITp{ zL|z+5!CEpXHnJXxuXaHIe+EvL(M}J?m@4hI17_c(LyQ?eQQg((E?yV!-@XVQdGxZ~ z6216Ks2P9dX@_~hky;ygh|$h0+3H|j4bqqnB9#iyhT^Yb#9_8gOKid{<>?#+VyP9L zrowh~4-`nH8zf;9&IN|q31zj_%+3jPKkvMs+XsZh>j>!(@a!6JfA6cEy+WDC(7vQ( z49f*|D^7&X$4)G&0=9JO5ZY>BZubIPYvgH+$2I#A$AbauA}hd+V5Awy-=Ou}hMKcJ zReVAb@+Io@qZjW!0{i)*R!63&TH=bC-_-wA zAPPd0mWlCASiDAee@oUluknIoNJ`Zz6$Cy z=FzjF8ox&`vN3YxM)u3na6l4IUMs57!JO~jaJuK2MB`?YtLD2RZ1h0o> z^k%%WE2Iz`e<`V)T4Hx{mA}dQ@KOZ!(W~~FM{qG+B`k<(`tBlU)*1~042PyPN^2F2 zL~Zv(MaZ!^wL=FAzX4ynXC{#QNDE)dTx{aYS34cw0v0#QfPc2Ngw1EQeXclM-7*d0 z1RU8L`3lgl7DZ2l0p-B!=*q2*X3KCW7N<`D_a+%hf9K&gAt7^^N*s`ff;a_k)xB-5 z7LKk7=LHnP!I-96Vi*#BGriP&Kj(M7d4BqWdwS`bK6ve317i-v;9(d&!oWi|!~u4% zz1tWf_&OX6c-IhAig8{X|X%(^&A>SZ-E2Ohq>#Fw!TQ(e-t45q2DCEm3 znkqBvlh3LiETEs~jxUETmB9K&r>v`VjH@g#OLuDCc!4cglaq$v28M<;GH7jw{d z2*{{QIBY`@FD~egV7-Mjw5{WQC=#B#7@f!MY|w8$*r)HGKD~eXSl`v3KD>C8dF=ZA z{JO5c5T6F_gpN6zNdYM;PJ(Nz%Lx%il?|bde-yk$I^G^Vf9*R?vV?+XZq>Wgr zk{W$}&jku4O`^9@0nDg1?E6~cjD`w~&f7OHjsrdlxV&&o+;u3fR%hTmSX&fe_^W}T zhaJ5lmZ2=mH&4$!e1crYvtKj>@7+59X|a2>whi%NAT4ae%oj?{7>ItS$u0JszoFj6 zfBSs%?j<$)qgU>3p5%A*1u27UWi54S$01(qdBhnVh2`ZbT_77j*+ef8DlX z`$QlS)>WmPh9hdZtweik>#i~xE84^s5tBf>B+fvtz^ED|Wd$FNE>wDl>_NN3lUe=n z@>2^h^<@~)^lBjRflDa}wg%pbx1ZGu`Tykh;%D{IYj?Zx{W_g#8if21W-ufAP`Sq48`No+13uA z1tL2R*b4f~ZHtaNOmk#nN=THROt6~pnp=<}lTg#seMin|YO7znOpwp6u_5%ibY~JI zx4kX`kW@jqitb*4^z4lOZjITuFQ`!Pc0eIm=$1?T+lvzaMHl&s(c#f6e|SGk{bdsj zskmhaN(tFeJK#lPq(u~gd8B7Opwa?x3j-I!BxiDTKhsGUzGg(xdl51wpjgFj;S8Dt zj3&8bf)x|M>!6!*D(8tI(#~y-(39Y3*bUeb>^4x7$+2jX2@lI!C<-E=+gl#$8?ipf z&wVThLBNlisa~#I9m7tie+-PB^u^XjnTty%p|*a-qUJ_e*&O%4?I!piab=(X2bcEI zOL%{2zrgRfnOL29cP?Wb$nX3V|>2Q6Zni30{_n;YK>TBS(QwnjS-Bm{GUs^VY>GM99G z%)Q6J#%)wTr}}8!f2le4t`q7424f4s90acp94R<-Y{p2}-B7iI<}f4X>ea;XMXWFj7EVty4;#K}>c6T5q)alLG*x=0NO#cGpU<{aieAx0B5&Ru35>dPhJ2bvq~f z1&!uwm{o|24FV|{wwxsLV7!?jI3BiUxasUsoq}c%7k%6a>Z{m*~4w{PFP$m4tT!o4c#7;6mhq>iB$$4H#0UwlThL$(D0 zUS1F)`i6lkYseJum@T5%Ya!oDC=ztSU?lf)KY>;g!(OAjFBsWKz`X;>=~P21Ys8)B z6^x6Wup+g^?mKc!{c1G2E5lAR!WkhNOWe{7gc#oTgnOeofwG5@hl7x|ha zT134j%#v+2U@vdAL@8A9F)7v+nUMv?rcyGrTS`b_Q&ue`6g)Iakq^k!m`uG!-M~(3>37mI5+P zaJFcf5ZI%92hcrmuMB|!{3jiI&~H{E`RIjvt)`D!My}j@#0u+qjyKV+sx{DFHkrUE zG@E`7GkJ3HjNULPMZ%zVD@2I!27^{0;y6FYAYQ_Tj5`@IQb2@!h94KfLsyK6?FL!t5?3Mt!U~GhcDx(wiWBynp@}qE`c*^%i)HuH zoE;-ME6SiGLpgX8S4~fgnO6=xm|9qAfOOj-mhZ_l8@9)N&+hFGKJ%-3eyWcjf8T$6 z(f9h`rMtbP{i`!!XsGS?h2`4dd8lS$%k; z6DDKt+0Sg9fP_{ks0RB~ieY>1SnE1*ozXDExc9n4iXVVOHB-Zm^s!PvvX!<~Xf!*U z#3#lyHmOb)ZF{;jHZLAXF_iBHfBRcB-DjdLz^Ef{Xz1p)oLf5%L@X1Jb9Xf3X$2H@ zWw%a_-@NzVBk}O&-SdZvm$to+UcXziIQ1_d)$GSpYzxSS`-s8uK?1nT`54g09V8TSoa_DlI>QmP=S;$ExW1reaLQFhe`oO0P2Z!jZxZ|DLe{-E>LboL) zd@xo=-os^pGeFpPNU9WJU)$ zEXX7gTAVaJ0)Mgs@r69RF|~Y4Mg7OWrWZfGa-@0m627KKnp_Ed8aC)HukrW`cmsh? zWHUlo1T(!%HO5rHtC}KFe}dK9$Ru~J-tEl5>H{swtHkyS^hHlQsIAPV>tOr9VW>;D z8C}kn+dzweBLuD>Xqpwu*Vjf6>lyHPb=g+DO_tieM#L$m(kfOvzR`2rdmfxthxlAj zF7|`ohsp)(Q_(5t_~;r_O~$F-wcrJ7acjf2X6dO&T(%hQs!Z#{1f)tkM(ZpU_irTL=CxKfAJjEc?UDSNGAY zcz<>IORp6!O-5~NXPqI-mum;Rz1aq$iIW8q3U`G9+y^YgAXyIXXJRr9Go-YLX9&6& zYz=suV<*zbSq6qAqoJloF%INn(4C^pb4vsB3lRYrYyF$MV=Tys9ZQ7`B%}2-04=;qHUKRRueM8M@3Pj-)&2V` zEc%24Y<+y`b^Pe%drfOb8`0AQyd0!;Oo^hoPaDPLB_XttEiioW6JlLxigA$WERHhk zupSdso6gjve`C&&g(V>sXByf8;bZJ(TX=fu05TsnPh-8S@GnjLeH;EGW?6j!tqIUu z*KMJB;FzMCJ`6~Ph8|wuwC0=;72yp&q_;l9(-MJsS%VukEgK}aJu8@Iwdgd@pmlnj zNrjP?pj+j`-+jKU&!0ZNoQ!z%>fJu9`|HM-<+y>!e}TD&!6^yTO*B+okzT~PFsT#* zU2fpv z5^Q<)e?;Sb&J6rJ*7zB~;?U;Ev*%<#e;8%tg}h$dtwG~9F05Z0N4(oNlR-N?gOPz#5(<=z_hpyc{RQ~ge_X1J0Hf&d~ z3JiH-#4rl?J0=gEfo15k7i2e)5VKLm!7i?|cDx_YTuKgJPql68jC`)Os0)mTNnMtC zf7+O7fGsS_I)Lq+d8Y~emTJL|Uc38R@aH|!CgIDW7M<7jYIZI}H-P8S6~&ij^D?EJ z)>+an#|CI7sH_Mao2?Nf_AA+u>Pno!!36~qk02cr1borr+ymIzES@cnqgnN>zIGqH zZ1=BS`QlItaB`AYqNsibuqq8rY1AT{e?gWvojY=2gGP(3wY!g@eL>16!k8O}bKxEBdhs9K z-oZ1sTsdaPGcV+;PnvrR=rW2Z4J4SI7SP@ufkt1gf&Io=$Oo+fr|vPlhbX3Pe{2kJ zoWS($WON5_horuhNA%Il_A|rT=chBHNIs9&6K@=01BeakfP$KPQxCz)wMD##v9$n* z6vg(j*E&A38|{HPUOBm21c6PH7GokSk{SmRzUq**2I**M`C?AN^R}K}u9tPMugaZk z6Y|_W1H6+yCp1H+vm!9LgLNYUe}7?aLD2#(Mb98mjZj+mX=RAPvjEX0Eu$|^6a{g3 z$LV$jj(AX#1GRa68a)2xyAMCa+pm3^|8!og=RbJqUW+?$8yH+rIF=akob=G322vHq zSzw~@(?G=4fKFaI3?yuUDUmrAFzPz@L7ynjsHCAQ7r+#N!)_k1H=?{_f5A&Tl`pVL z&u+Q>F291*0fP9~6-BUC+J@q@7_7jltQH1*Qni6YDbV4@3!7Uo+LM+QIvS`%z=Lg4 zd?u!G@EYS?oh@+FEEkF67?L|5^pJr6O$uHXpR&?@abj!j>xyih0n-i`skddpzxnR%`gdFa`QQoB13#4&3kS#LN1f{uD8mi+BcGZ*px?c0~T zZjWBU*Gho{@(^W6qd189tl4SkXhFK5)1@XC>}vtiZRuzU45Gy)6HsoP=`Ar3Bxkr6 zoPmyy94VBiA*&b^@PxjRmtdpNPpg())*WYwq#0uZhB3#4f2+FD3a!K5B_I}`z3(Kj zgU6^naf0t_ZY}P}P`6lz5E(RTCSn0kW#W9-Ev0Wzn^xkG2k1ha#7=eE?2V-E2H$@1 z;gxpGqnGVIyZ!k=MG_GskX4C2;gV+E!u?XN&d|%3tC;g4(zV?6qA#`@H8ktAy<4Pe zL5xFVKxE2?f34|Wn?h_HX$Lb($){$IvA}Fx;u{CC+x-!pX$5p_*t+DAAatCyG3T@! zLb1T!@60u(Fsxt1gn2-THTYB;2By(o2#1hgm_q=xkn`U*2x=)JYqMQ=5K&`JYlc9@ zUV8g6{f8glz4^a>grWIueeRaurwAXsfUoV6qK~3Ae>3rgLB?{JICy&<2H}J{qxPIu zp(-kTjW>_uiwj%04N=an$Vq z0`=7_fA8Q@N@qP>D6^GYA&qid4gAFw;C@lF^Vns(eeJFmzqK`H5LV!Ry#SJ&w)9M9) zOKjP??mGi4+9ya0kzr&BmX1BU5m3NK83TZ|eujP=!4pnun;daflLvqn; zwF7DbP$z4hS8WvNS*>|e;QtE zEQocFY|z%}_E_p^*I;}r7_$2%%cg~yk$x~MbArIg=!dfB#y*u?a3nbZB!I>#wy8#{ zz%982&LFA{qCYmmUD&sH2Rx+-S&lP%?E`6plik9ve)Ih1hYxS->G_Xu{_Wr1zI0t5 zy?(bnn6KwkR>a8%Djrw`naK@jf55dpp=QD$8RlIruj3t~WLKydODmbIt&og4m+3s` z-k6ZoZetw?5VYxr-*Hp#aqZ#BR{`0#kgF-X-S*C=^C)|5aqfW*Y1>r?=<;kJE-K)m zN6n=i;=0armt${_a(x2DzGrrs7-IAp(uidNJBP3}dbmu%%XPoUBvtzUulg*YB1_F$Gbi%wJ6S2d1OedNQ zoy6&z=9=2=>;cYuSmpSB8eR zdFF!l6O1=TiKvUOJwu0Ye{?obN7UuMLXka++(j~>dq$Mqb)B%5)z|Qg2Mx?;`Gm%` zAUIhoaQv~`xwgOmt`PD?M&wbY$edShy?;4lDK!geClZ|VS3_MsUvGy^nEH)-7f6G)D)BRV)Hg8Kw zeobq(ia{U_@=_Jx%)#Usi_r;}uD*50nvlhIQVIrYmvr@lowCdjeipKmvHDV=oRRXK z31TRyzlM5M0lcL+pwgLZj1&E?-23H(`uz6Aj?AMM@8=hF{PbOQ1+$b&ap>tY8e*tW z7R-rkh%%f(mCIMOf1zm@!(QFH?>0)q=Ioj76aSWbw(X74@fbCj+-Yvi!lPDFJ&|g~ zY|k)g9?(s?ZJNSo5rNdf!(D2AqX@wi}TK(_7>%@!RohvAcB``!EZ&4(w;fBaZ4mhd0Fc0a$S`zI^e zL<*+b;a%9EVQSd{P|jHks;7CH%V;=O151ktNsXOL69UhJMWO@$aR4V{u$Uv0oUjik zO6GlLhZm~45~%;QwgF_n+&Z`0BPv?hH~=K=7M(pXr;lb6v#|GZnwZQinc6UTo%mr# zGqUQm5Y_i4e;75fmWCQk-^UT$2j2IbV7Mw|SOZ34EqGy3@)-y$`R3be`ghMi*vC&# z{^L0>q6iCSqHd*Z~UuP}16vZ2+bKgW*<8)Y~HL=s{X@ zvZK)n2Y)5z4mZm>z+qhOdwuNU-EM#Tmm+?SS`f{)HBLw8*k|?*jQ3n{Q1m%; z|f;HfhHwkot9)j`_FMJo_AHc{WL{pOR3<#gmsAIA% zwGGM%PZgp-dn2evVJxA109}sv% z^Xq^`V;1}*$ZB*H7LGN5Z5R=QTXHB2VLOro*g(Ma;T;3amaYL$C8{|=H)*zmhTy>-)>r|eIXUVQ+(>{rK%B_*cKT_`~yu zvOm1kOnvauy~YFZeW4h!MZ1LMdtm>(V@?rJ_K-PD8;NWj6-QQBT%&Z*z@sL!X@qKZ zKfwD%&2`O*kWX6XU~1YTIt@cDZR>G?e{FTrLDu80Mbps{GxRD*D}zxU=&g?$v~&i0 zHuwX_m~I_^Ql-*if?JCeo+4^31+hG>r8<^!>qzjlk+!>A(exaI2Ik~I{Hz7?{?)17 zw#I*jUg{6_DPDU2K6>fyw@P1p+v|AuXi2h98+hI8!tq^>;2q}h@nI71c-!!xf9aT{ zvSu^uSwmr`(_TE>qZWi_TNMS*p*!{_gu{|2z$!aUHinsOj@m8zrdz~AuSJ0g1VD)! zCCDYh^=da8OD`(W55H zBcKq8Qrq5__r_sDtmN0IZcOV1gOXi^Et?qWOfne0mt{*Ryo%OH9N5TkipW@sNvugN zb+)+&jYyz-dE6dvCWGM{GpsdjeP8w&tG<2XRfQ(Vs;k_WZ7u*Wwny`ke_LRFJ8)D3 zG1jH`#Rt^7s$68Ja`3=;14)GmUFh6QsOb&R&Po#M+uKdkMTdQkA3uKl^Gk(@2QS{; zyfJ;*HA$1RH#Q+`z7F_(3|2peeZBb*2eS`u-_vmW5HqvpT!uU7U^t*+LanGIwELAh zvE2&eqhR=7j}be1_y`JOe=_=v(I7fI#?Vq2%ueTrSMf}5~7xJ~T@J50a5;8$34uWbq z$eUBxDUEeZQewqe*b2zJ=$&v9Jof zr*Rg~b~YCI8!rn#dih?Xde8;YqXnkG6rw2deHd0X>w6pgB$ojcgK1>64bK|s+G*fBp;zcv$CGSZA69c@R-WCU1i1ago^5~#K?%~Q&K5qX zS6kb`Y8IVfhXH`?5biogZ)F>tTbsPbD%X=hv~rxaV3ZIH;4gSIE_@AwM5GU6UMPZeWyzkw3vW3^UTP_^Kq9W@G)Gy{S`c}~mQvGGN5 zA`_t`z+Dl^LP_YDX^XubZeb994IcQxN|uP2Kw*)He+~^MAUxeNHSw+0B{G}Jac~{_ zu;v?O_O5V%V!n4nym!F-9R2oU{`&dD$2adjou}Ww^xl2++TA{&^d+%GM7@ekanryD z*qva3!7vV0yO{4jd0+8F8DJI#hUkv&(g6i#_eBinEgdu< zdUFKUjJ9=-&zu&FC6Nz`9D8+mr9GPh1Z5kY z!3+3W0vLR6NgptXU%Z}}D6<8GR+#vq)?;-Wf2V~PBTUEBTHgw+-atnxXwm{`HG&u{ z1z;H0(c)8u@Lo$N^pCy4UpOGa9EQX-AT+mi{$&OnEMrbTLVQDi(I9I>1tzC#l;iQ~ zDHPKfzh0L`X`qQ&jDT>J=4g!MB~<AY62jyLBUmi+wW20tr#D@*#nq2y^sX+~nWJ zf5-QL>3^_4zI0I^y?FOIVEuei8}~Ej)SeR?Y&_t}x~k^IDjBs=7Z~PeA9Or{h=YJb zcFjCSoonbK> z3?-{8`d1h~fo*6o=4|rJ&E3G;HUuaje{5?yDs~FO2DVm@9>Xu-+$Hi9_DnWEV-tdX zm_=W^X@?{Itccr*x4(UU^W8gp`&55=^CB4b!HajF0sj1?7Q&d^U}?oJTxr(qiK@@} z)Av3(ajbxovVm%=_Mb;_L5wo9$-`+f%#q&=FzqfCGeDhN8{K2bt&u`|h z-is~~?j6TDNgHi3wS5)AF;LVfe~#G#|9Zs%1|_hQ!||a`XW$pwnNX#hA`k$A%~{@& z#D>mkNg?^{mc}?rTsk18z7eTjx9{IP9fWv1oCF_Q;|#te11maMb@;{kxT2tRIx@Cb zD^&oy(XrVSSceXqC9Ahq8)cjp6&SBC4V{s|%niY=)W@{Z`)&aD_x00NfBnUWKYaK5 zuNU=KAME3E*~jl*+A%$P0q;yTU$?=eHrxhao|tZcoD0Lz$W_jA_I5-8>hDWNTc0oicUnisZpGzc?pkn=trGX>=^hq6_Gt)8w!BzXkN#>%`SULJL~A_31m(5h9PaW zzBLYJ9KrvCt5MM@uUNhMU;^)P=4lGkaa$#U^d<5yDW!R0i*8`tf03pjQNQip{LlZ+ zsOqCv?&~G}-~N(a`mg`}zyH_&Q}HIg{=dK2O@sjZJM2oxx+-(hHVf_3#TxBvuZUQ5 zz;a*RRr<-U=>9h#!N(Sh?$n8@H641{P(9Tepg_BB!OM4lhW-4hMe?UNn^)Tq zuZia6%je`VQD|EYX?iR!FLKQ*Dwo}90l2*SoY}lj6bmr@f4;M?bxz=XaXbo0ngvCg ziL}}$Q(K$Z(M-m1y zs1soL^NiIQsV~zV$P9TyO@COYj#mSsO)!gfMN(m@)fBzGtp8NcPg&>9yMhVhLw)@8 zQak6-Yxo+7f6{l+nFCPU0nM|n)&l|w@cZ+uu*f(Qv%jcLo(`mc@5tS2)!9L)KxZ)x zY}2C_S}&nvUzP7fqG&`vpG9YxxvY(~v%#f0__pvruqCP4G+3+?0-uhk2kzEuZmAhY z=W-zQ2LwCH4|23Yw!3B^s#n9LL)WxUhl9XvAZ)w+fq0g=zcpC?|QVjDg zxAlp7e)>WNwomVWcrl0g;03&YXz5Eaap6_6?TWjFyC4D&k1IUtyY|tJ2I6Q!Xl0e0 zn1NqqLC!TW9u}yu5c*&6!S<+an8B5~I;7za+*?x?nv7TB=zv23Kcjr7!@$i=YZ81Q z3}hDCe{m46Nd@3=ggAn8l0d|Iwt@y1+Iq(B6et{f>RLsMQkI{P0R?TW6AUvO8YOwM zI#EWtuQg#3=_9wIo%!=!6bk+yKED6-{>572W0&r=XLalgR=*8&L~R9TILAh|Z!>f1 ziZxohilAqt%uy9+FHYz^h$~RmVV?kZP3m)Xf6S5!Ja)vVoR&y+6pMrg=D@sX&9etQ zKzF3VevW|uFsDFJh?9H-aJ|kG`@_tp10eO>UUgWf6TWACDNjc7v0+MQ+q5@0$KZsp>E64pF-KIHG-zvx4L^s2qa*cUs8=Eg0n*>^)Gv!N3_ zf2M&MzFH_+@nXBemTkZ&aAIz4l&sdh_F;tUZdnI59^R`nt7CQ>xFXqIH&f!F*yv7Y z!FxuI|jShzVyQU}VT!-qxCODv0ECuKd{! z2tRt=?yLNtx4w8C$kvb`fyDtiNXAU;)o$D!l?@Lm#A)^>^WC*0H-Z`fXvzonNo@FJ zC!UdNZh}5?<63O&fuOU@Z9Gn^e+!iZYGemp>TW_~w*}hf!Y7W&R>w3hY=;{;L|HTU zRj6CsI;;o#bhIK-_+JyaxQ_H_KZu$VBdfHhjCMAk@zAH>bs-bN`@eqgEIS4NXhTMrP447CI|1`X3O^k z?Xwbdsxu?TYQqXS9@sDj1y_Nj;1@4ppFlZq=$vy!O@nL*eYnx~z!`R&f~^gsr7I9h z2x7P=mJvGVbzABGjoVv$e;1WcuVqRfy?(D{4*gtcy}nFG821IYizD1)v<(70Hpb}a z=z{> zAjEQ3V9-QrCFpS|E5z|>33;D@>cQh6g=irYgKx`Llw86@%pT6ffAyWKGvI1#4E)4> zLF&$XaZ(SN*z;!Cn1zs0LwbmBfggXDKfcTQ`0CF0(X02`&NooQT$t`zX`~(@oY-~G zwn@>8jI+V3m0lRt#{io(1qylgLu9T_glI;`y-96k82>rki=V4ZlAAvRz;duXCJon6(Uf&%@m;~lsv zZ8WZSF=}zrbaZ93z^fflZ?p+iUaP2sD}>gu7jcUO7U?$CpOw;=pNkAPj!q@F;h^mX zl!%Vt;Q|UDt_10w(9bx#bKAK9H8jkc+3apWGsMEJ4^AX?f0P4&?1(LN#08rLA8eLBSl;cF-GuD8|YK#F&8>25O@K9+Tu$!FSHlf9BDhm+@I^ z6woEK?A%rme+OWxQy2QBec==m6WsG0CkHZw4p0Wb^vcK2*^UT2xfsgmDJ-+aJXWOI zvy6#=e8mtk4cEE%k%PdY^oThL6iadx=?impw-v;{`|D+UDO393)w>;E{#qCANK0uE zvY691Q9!AOuarm6vBwoJH$;$uTxocO+HsC{f;gx}f61Ddrse6f#+*YAwS#nJyD-a; zFEX8ACnPwiQl7gQ7{swLc|=QtoZKKex485f2FyW}^5{N# z{k~q;0{`W=J+c8!0Rb1ci?adc1`E@_zWMm+M|=B!c$a&+0Y(DfzPH1=0UiW@V0T&n z9m|(WgbLJb3Rb?doYr_ZDdbcyu|YrhB~!NRXq_?ZMf21u1mA#+9NCd@%!pWy0dY9F z&Zsh3tu3UmD3*j3230ZMTRQ55UM-3{=TUECBM6E~?vB{)_DYe+!)kukl2#D?7X4eKy5XiHCn9H(-zjIfG2>t}h$!=kVctGJB$%!}tG;%`@873cpDN`MU;^&!MlfqXj=J_BM>?SA--}1ozh%5N^MMK)7SML7B z^&jKzlHc*y1VQwZCzukPnIi`xmRQ~pvmdiD7aE;}{6BSc_8F$-1kbW;fNDX5rnbsB z5Jp_-jSTdeu-7@_vb^n8iLRYyZtxI~GK|k8x4~M>Q?^9T7|mIKZAr1{0NTn!$Z*mM zG!WVp#2jItz`Q_ax9P4IpI3drUc78lfG@W(yXOnuN$1IMGc_h!hB%{O&a1Om&2jea zP~m^FmpWIEUbFk#YO)9-{(eB@#&E?h$cB`yt&Q}U(l|P@!83Z{UaagyP=St+OWtCM1XAUI>cZl~4o1A#3@6n3G z_u2VoNv^ejgwT-?Ge*o|Y%B6lWMsfyZ~;h}5s{LGWh1xy9GGzh47ez+3qAF<&0+Uu zyx$(!gWlcWuCIPom6bvu529fTZHgSO%^mBjO2Gcq?T4bEK!foSW0&_+LZg|!(0QPQffOJnkG2h2{3 zL7p|e_k7;+3MC$4QUA^%aW-fBXj+27mt7fB0QA&>wvp|LsZp zzyAG6OAldW$lM9?x^;A{W{YWQ+S)W@j=QgnH5Q`IA*KS-+57wI9QSLnAK*QH~akcM^a=N{=@9Fp$`p`bwX=+3J((g&@f8YOp{{?*#2kgY%YiM`5%$`S%DsO8o zXjqU@Ls#J`;1M6xK1e-;oYF5I+!D-x-m53>ZbsIEcEWU09Xm7N2xlIO;9!rmnIz)n zx8SLVRKUNv*#OH~1M-x=%Kpm9#^OwZh1d;$V%+o(cX)iQ4RPpzFqqVD7tP%lFcBP; z@q&#q7J{3e%UCZpl8j;2g-ozmJ%9f>`w#z8Cw@loxv9S`dA+w--cNb$W#~2c?HYdUv3>1Za4WX#L|gT=!*OlG!xlTM0sh;6 z8VwmPcwjQA`r>rn9eDQoZLOcL%NO~!~ zEl=`4t-bLm6TsPfp)yNik(A~IvQbsKeB(faoAKT-IM_B#rv3i&^x#FWI&`dCMJt{`{OHPw(qHf%P|e_qt!BmojbLZ_ClVXga^| zB!+A8heQHkN!($_TTRC|5lgEKl(QQ&QkdYe_emGRDR@_T$^gt zvntOQ8D+U2d-|fwVqW!+e7}0EHU}DbTjMz1rt-5??k_}4on?Kf=&|(_`|9+d{_IVey% z8_EY{2@K9ptk0>Io0v#RjqSJRiF0d%9EYJ?Z(XG(Q^CZ4GkS5X7=^z-~TE8uKu@w zt$(4^=uiLp&;Rm!l^TD4^o{%-V_{`qUf4v#|qt79~*^Kpz&Fp;A%=V%vtjZmW!u*Kw z@9t=$Nw0x1c8)vp9U5OBZ^IPud{gj5l_;ADv9TxeWApar-eaQn@Og|n z)4vKa{4I{X|LA*v_}4P*k9f%b^Rf4o7fp|6j(-Glv_of?-lBc=92HB{i zZ@gW$!h2$#?9^?s36q?1;M(@a2Ecm$zXPQCm-*44B0;t$oiyx~^KKU2i0WDNtd3hp zK7V81W7wM^yl+HG+H&1#h}+l(49leUn(vW|gExD9?R_$-AFGxd@`H){7`M0jD>lsE z$bzUfm?NQ(f8lAFM9h3+; zu@)1zL$Tl#UmkUlX&BUEA(43d>C7ta02&7G;)JPxv$S_;Ym1M5|7Giw+3V2J&IXeC z`}P{Q+HWJce=E<_AAQ^Y`eW5+8aS4W_Nu(gZ1nAAfbv}*c1ibL8p*s-_!`=EjG8vD z?vepAG4B~UMi?zqcb}?$)x6HjJuLe;wvc(;=kB?(cg6IQYyI|P1(yQSVFyc&&Bbmi zkv>R&dxEnzY2ZCX8|RzR;(G5<9Sc5v z)Ko_*dWSM#DQkyuP>RQWkE!l5n;-Ffet&a+p=Ig++cop@AAV1l_@nRI@8}W}Za{iH{Hx&}N3k4@ao-X7 z;%vL!qEs=)VQstsr2pcOUVlIT@?4GPw@&Ps14&V=t%H#vqOrbjqoeqpvX+glAl}D+ z)mHX>+jwXsH*(8D^t0DDb;q%)Rp6|#X8ta(@QJlSvY761@nAM80M~Cb9i}mg z&0P1|X>SV^h-$tr#pYY5N89cAbvhGYYh6vOnc15A4lAe13-aHXl6m$y#9c$sBa32+ zeqOHjPA}vM+OG5Eso#2Y{?qSrg8$%ud-gkyXkEPxJL4-_dGlf(ucWVHwGH7#`$#`F zL%q!{;HS>&?z!mX?sX*RI%;jork3eGPi^z=;=t-{eh8iQ9o)@BOP&qBZ@%ySW%=5F z-}b-po%UnNL6%t*>9u#XPpWvW{Jcq68+yLqxmH_JPynaF70CM_nV%Ov=IoSz#GG4t zb)KGA+O@UAsCU~H~42l8iJLLb`Xe?E%v z(B9{2c}EVi(%7+^Hh>l@I~7t*sfgL*p5dIm?#t&nRj zUOFo>7>CT2^=kI3@0dt!5!=}k-Y%H44ZWWQ!IuREAPKYNvEo;%*LHK-*V z)ni@j?`*8~=dQ2fH;6eJ{oA?Ue{D1F%e@YD^bkRL6lWzuUR!x8&z?gD{p7$%egSG89Dq`6VTMJ|NKY!mhNvMo1Y^fA&f6s`&OaO_I6l6D?G37w=+i0uiiIC#XF7unkZvQF5E|BiQINq&*aA5(xt+<^#AxT zMNHVzc6+`0aTz|{jqLq>qiAIuqk^zB$HAk1y;D|g8p*cyqp825 z+$3oP7MD@%%sU`i$@RiM)&lXxvj~yV?|Av>jM-gD@852)A{qep-TjQS_~iBY2)Ls~ zF=4sNffgRxbL1Ww)wsOs_!b_Q5*N0>YA{09-AA|-X zT77>DAv|lPe?j{z_5G;weds2TC^9!w-P5(wz0r|=35a>u_2zaCQcYvX?(-o~m@fXr z?azn$3NB&YyM@M)W*1g{*F@RQFt<6qh0hA7UzT__1t6=;2Y=rfkrxKDUTVT#KO5PK zNdMepm1!PceKo!UCxvdjk#Nd)q~ok!{ymQV{5WeKe-{wAMOL414e7XVwVme3xnL4q zh$!A9cGk@yucf5Z2=vyiT-nZObB%8PChXR#{DRp$r`b$TO}+{c$lP@8XCE%sGLQDt zu?2<3dU6}tliuFSO?i3KMKwgsV+Q07QXwha%|z_XkzJxMK02~o#5CVqBlKx|z6pNT zJCo+lf8Ky9>er2S)0(`mA+!1#9+34ca}cLkh9;Gx3U3sli6{(Pksz)rFPCbQ>Z@N`Puy#5sy!nn2UmP9b2wd z$cnW_jkdPlY8z5-?$FIrt?w~-ahrFE_w57!{sJ!c0cOtnEv^jb{w(4?OpY9x<2h)1^AU zgPgX)Crb}=Zh7ojPRtv0`N|vLw}S@yZvAU?UH5x&FD7eGNCa>C?n@+hZ}sgGz2CgZ zf9sx}vW}nbUf-@_liHdMeW=Sf7SJ2QiJO_iS59a=ph0wSc<3C=16;<~r+6b0tiOD; z`q78cHS8Yw_PVzz>2c6|GJp<9tjDQnBJ*85C>OB8;W51Dbr9sNva7Xq4_^wQ!aBco zh#odpoRPkg2IaZ;PXEYgive`-_q!w!e^*j0AvJfcXQOF3>cNzacVN%cYFWF zjt$~pr+S~QpECq+{jSz}+>1^LKkL+Yoik8^X{5&IA^*Wr{NW&Yc?LM4pK*@3ho1GdUdABZHW(x`D2zn<2n5wHrBoT6|02a)e=`%h(h)gK zi)F|B7=ydFv59hwHalS{>ub^6UhmNXU_36R#}g#A9DD1FTpImEamAArZh`8J4x`Tf z4!7d)pl1n<2=tC&%Nk#tZ)NvD3tB|3Xf0l~X@O@#E^(Ht)Y^4=9Gf{n4D!%-yOqaE zEA*>F5WtnsRY9Hf@93kue}`SFK-)cy`pI;?H(ShgR|2Y_X}w2ZfX?jeKK^KiJK4Z? zY(b3$d)gP<`%b$I%U4pMontN_3)1FSG#CSQZ|U;Y-uUb!yK$J&p6sr?`*+BpU)Z9t z)8940NX)hRNs^52GHDq$nQiwLj~8aWNeBxp)*$RrbDU(L(~Ru>e^k4VWom2aUWqWV z=9p=M?MCK!_rkEIW6{T4Dp}w1)8twham1l=ixjNhOMs_yn`uiOV3|2nB5&Phvu_}S zOLK;8fD+|nnq|vxzuD-Vc=a0ZiHw^4=5F22vE6%n z>73t6I-Nh>$E^=!e}C^|D?1Mmlh2a4jY{3I2JPhc*5VvN5OcTA9Eny=;U%6%W92yz zJgg;?NgvU#JX!stOtTqp-I|W$oXxiIkOkd#h0$%5 zt^O&}VljI^UeqK7!#J(rMrbbbeQ?H%58gJx;Cu6Ine?@cf2BMnl=OA6VOIBW3rHK9 zy>tBTK3ZqLfxh#7!|zo-Y%SSHe+Rk>%Q{##yS(Sx0gB2#R_)YtOkI9nJYNAh$cNLi zH~YMIJ^S8n{dU!F-p|RyE|Mw#F{XQB6ZZNvl%N&C5!A;nvi;OC@1JoAVvpeWJ70cV z$#y0ii}RjYf6W>f9zUt>V!9nh;5_2GMZbQa_#l>10*(fdBdEyh7%)Vljm*+F-mot>BMx(k8bpDv(xYux4Mq*PmP52!%NIg;H1kM7KU+hc`0=eXZ=M$mo8*>kMt*1>R`i1Xf| zlA43X&$xt!e7D;;)uqX7w)YW*6}J1fK0`J4S%-tuc^*D2POEoJZBEk2DOjziF;KN> zYpsk?f18dlJV&8x4l30Nx(vOKvc=t^owcT&pK%GhSratj`7WfU`<~9D`_0zT@?!3^ z88HWNxM-o$4<>)H+l{q=S@DagG1iM)?(uNNcZp(m2eM?9VLivEt$2(hodoOcGG;3* zg}D6_iA9Xf=2-OJr<}uFAa}I64?E1Vw{Cl{#=bbqFmnM|?YyHNhFJaFe{Z|7kh zc$7nqq6pkVS?^8m9{ZjI)Vp)+b@s`Y)XVDeK_^)AsZFKVaeOqj(+fuw+P;}2SU+^6U*l5lorh8yECA(5Ql5b|_-f!Fz!=l2`f zXEuWUH{@;eHu@i0WBHlWFzwfEf6xLo&uF9M-Gr#3EtL`V(29GezjJpzt3JV{E<4}M zOD84-8*!E;eOY9_RB&x@nkr#=bW+mm3B5|N?tMOF{H6B3Z+)!+G_3o~n=nR1`NI1} z&)qSszp?a%_HKOm;+^}}8F8&0H$P504DA-URb#&ajVK;J#4~U5Fg6Lte|_!4>$ZF* z+2p9atdlqH2xwqt<*%<`U;N1r0nNzYhk7HkxmX|NH zHF0j-ar#Llzt(Gla zCk=bg~A)14eQD5sJyAsCv_kko<5rYIEv6x{mE9;cr@m@uJKoK zmi*iaQXQ|RWVW^@e?sd}D#_?2?M%dVao)tLXv1=!@R7V?9dTw3Uw1Zi-ewuHdtH54 zmiaCuO)ILMfh}KLIjv0{)Kw^E(WSI6nUzo0gT1>_z@ym~^O|un8LLlcFuS!a^t?)-e+qh@N#KvaKsBD`+dNAUX)&4e_ilMX7^*SAI6W6siX8>vDDoIHzm&AwDF zvdHH8@GySUe_Cfc%N+R7Rmo|{IrI#9Jr1Qvhmng`QpoQ2zO{#r9bsb{`C1=T7JHC} z?+D1`aIbE&-fXb#y6-C%r4VElMSj!Y*zR)pI)Yjp{kiDn$s3q+PMw7!`o^)%c7>N< zAEpI}U!Ae*8v*m0PNL(N5G+$_eGd(vOHAps@3a^iH@Y<%65dyP^Dy+uuxba%yXRQv^g0SvxJyFCwNqkNy?N=E>0E)2`@XB}uGfgXhK|7_K+C;5P^hp`lY{ z;Q0QcfA==>VGZL$8XaT(HnXOUx&x+c+V$4LqoVIsoHgg3jVN3yQ)Da@W9UOaubAEn z?$9D$?im!h$Np+)bu>m(;;FNf%Cy^+!Od}DC%W0VqsUV7Gd+4rKV!k~>%deHNzRC6 zJS^Q_O{EX;8Q%qZ{AAoIZLU?gP>{UYGTnKe?+B zf32XBMM(on8!$&wMxn&)-Hgww2xoppeh&PBRRgPz0z=i#S z;dkr8^UG{vH>I9T=7I2$pOJ(axm_96f0JgBgl2HqYS(DgDxCW>)YtoKiimsf&oU#V_4!aja3a2WXDVWp^o?dX6ym42byE9BCU6n(%)?RE|(!v$h*^W-g>iLM6T-|4jsB?AiwOx!SF`Eyb=A?x2*4_rIW$r8#=(MjCo5|FktOe zz}j`@_Pv?P;*)>I=s2Qh?t_nJNq!6jY0H?|H@*yfb>@|JP`z}pfsO+9$gTPHMz9NR z{7&o9Svp&Lx2E)yD^Am;RMfDEe^X%zQ3jYebVh6Buo!9X^0nfu@6Qx{UnwkY+}(F- zaYlOia{Gd=H~Q}T7o2~M%MYEpf{FJ<1q7v}TnJG_YjKgKtwRXVxCCuSj&)T?J!#Hych z31CU6U775&YpwU?4e12F<%@IBWqI~7#-^@mIVC)5U7hU8T6M_Hj=-+0FcNS7iJDf(W+Q#HE{E`lYXYvBe&5NIL3G_n;u~SHC zM^A7pIJ5aT1My{ue|CK(@iV0@ZY*q%vmsaEa>0}v`xElO+1LAuqS{xB6IpX|n7Qj@ zkpe*+dzX@^R5FwAhgHezKeQItqe?O@;*18SeL9} zXHGZ1Yna+{GFBq)nmFIa*_Ui@aEU#dy4mZQ=FdO5>jzxIe?GeyVJTMe73(qadq>v5 zz=wu3Xn`Y>r-99Pan@bjPi<<2FU9T{5}Ps7js-^OvC~*iQt`kSoYSkJEv z;4=MZT!I47cltIjWay?t=8=9C+P))|y^AxSxyPF-|R7!UFV(`JU;0JH_In$oA zA#9&&e*jHPb{e?cjo~gNEZ(O{vThk2@o~EL%5|Eue`j?N1hw1T)%P5Asi&0BMfn^X zt>67_PcOV)r&>>I-&Dq*(U&uN^e%W*PH;HUHtvf{d}`ZXNZSplijNr{N) zbLt>5V#3Uz8dl~PHa0xZI;*c7v7UBx_II36l;(|%`r7vnUx#r+luLWNdu~%&m|LS9 zk(&-9f8oqXd`$9+Y3Zg7SV)24d+Y~yDxQP$`~RNZ>`xA zjqPwN#@2755p43$921@ZCbm^Qf5rHgDW=$ge{UZ2$z=XNla!?ww%1!jPLsPlc#w$n z=J|%p3sg0oBJ@AZrcT-k65l;W#>au+V4RoLCxlPG5aDBUP_B5Lm$IFe^!mxzdDf~1 z+D;0K^=UYe`#kOh?G?ND7PW|aGK_d;2=;K%hG+bcd}otb74_=9q58!}Ii}Dd<)@3X zf6ofvG!4X-Z?V>;pQ(3X5`P6HmI&$HOGKpV!DuNZ!aq+B&-UK#>dV-c(3~3Y)F)?9 z$ZapfYfudysx!wH4??&u$Is5|WX7c9MwRnrWm=>33gBcj(g$(IrX!(1+lH`M>L(j@ zenx9{`=B3@6A>KnQyu6>GaSpd1z0_Sf0P~Vj7Y^9dN>vsf(`3~$eMld11;_Nplyvc zKL;2RyUyc`VeEwA<^o*;p~-Z;c0PYuiXWo~L^z<&%jJ+WoP2o4%N^u1NKy9Ba?r4Y zHkv1AVe~YIRe=Q2EeD?_`NqhrN^)U!z40PP-Rm`qX^F~w?fHlpoQj2W)fvMTf5W;Vbe{U!Mjv`K zHP0`%axUHJszpPf^_+vIOmBshdLl52v~I(DUCHx}p5aB_J_G0?$w?Hpb$0k8e6@X# zSMr6HV%@`%HTb6`NP^ha-_z&&e^!b-A~fDaNWO|6+6s6RTjjlMI*Gl`GgcCg{i-!? z$CUr3avU+TZ~+JDm2a_(;)N$|s{12%AzUVzgbSP`ciRV-D(=|$V%9v;gwA>V(HnKi z9dvF^>Om&C9aogiHW=4ZZ5@lC;TvmjCLD6>bf6{Y2z%SP28qa?RX^hrf2cc+k%~*I zQFcT6DB9_p!|;JwAP<|&BJt*-BhhKU{~p~>Zxtk&qVDgSS8-1b7zIkNC_DW((rM{*`;fA5CwJlBKxG9n?O7rH9k)d^CPH=46ugqt(YL|J{7tVgI` zVZo(!|uT zJe5x-{IVm^oX_coVPn#ik@ZD1HeLW#LQVVj0xdu)2*|6Bm%UX5&8oIZ>DD@hNpSV6 zs$%@nmK`6HkgufAP%b^7Rf56K17-51gz@Pbl;co>29f0q)e+b=p$OKc$LzH=*F z^AI8sU;E8d755I;BtOqdCe?cPCq>8SRvX-{$$q2)Bi!0wSP?r4p#vdEPUL#mx3hx} zcpJU!pQC5#wX^r9z@ppMW!H<|0VV4v#wTRazYKS4t`(^*0tdK_dxRqHy! z3LEHt3@hnPRV4!Y-JWgP-Y^2zcJTc&p&>%$pcuaI9V=Dsj*OR`kPFdj_f_6Roe?7TvSlzc4b2Wt>)f#1)lWFG7 zMpaobNTdRwS+8Z^U})WClMqXf&eXFVfPEwUK;J#nEBhTTg9(TWK562-M=3sMO46hb z&fqBJuX3!U@41;vl7rnhw+V%1L>=!gPFQr-g*83#nULpM=6S|0DGi7_pusuZcuvB2 z%mdvte{eie51DY^XvD^>!^VX1eZTC7*`L5B-Ki8^uZ%gWQ&an5V5ach0n&Y^t>tuX zeTkv36fK_ih1u_U={P`in02M+Yg-&=+-=|oIj8`VNGuHZk_oe@zN?`_6Nc;iJRRTw zcN@;M@RIW~)g7^NcJK-T+_cMD-{D?G6#bh?f4nDFFFG_`GV*x&X0%@5*3xO;s>llzuV+6-WJP~Zcp1cmt_<#x-L0Ns= ze-(Js^n(px9`L!; z-;UAsv-IsQr@yP~=-_kE9Z_&bvE_ZkPG9m_C`?_vv2^9AwtBRrGlSCWsv24NTTgEr zh^^tZI7H8Ij5KM%Nzw1X&8zd%8359}OF2wcwGFqPrni0c;710M?m3<}FcwdUI@i#Rml_A$4Pl6tHDBT(zhSE_Q>PJsZZC|_FdoPFmbJE zjh)z~2+LN7dwttuqP<_UxS+3%H$=NgkGPLvNxuj%@KT_9d}v4_4TpZ=f71%GFdO0b zLoT7RA0ne~w8i#8+C48 zogLt_`$Dyq(}^u$S7cz*XUG0YpFiOeQUzMsGiu}9dU0sMH1o^datOJn=^U21W?y*O z!l>bd+k+=}o_3_bqzPq|e{Ji_ao1c0JF?m$<8>y-;nrt2YlBohzUgb z6x(iFQLa|wjhLP7t?O84Y$@y z6tspk8)#EYq<-PU-n7^Rpn>7Y2az4nZ)puW(grkkoR4#7SJ@=3e@j~fyVTEl2XY{` z*aZrw4=pp8rheqT1j907W4=31szArcRs*rM*OP6(j3h@QmzLKU!0h-|&R8`;Ktt#0 zYMZ})6Q^vYpgpe2<8TkS15JNCd_(CpZ2jh z$nQ%wt*rh+?<~$Ef6Lj2?YZHInybe1)1 z(|RI>xod5Kr;dQseL#oF^`(XD%)pKgswKIHA^IjxSx!&1f5GOreO>3$`pQJYW4E(| z?Qjvr#N4(QhdSRofSac1mlLKuy)7lGg=O8|#20d5%Se!>U}=J{^@YUUAIB($@h~D6 zVU1%12lUs*4W+u?GMu$@rId(uc#sql)3T1kBLw_lBu`!z1u!PF*!W|A!#~TZb^6fJdJt2B4#e3uh0PK()OK7hNCX|Z`H50lCHE<_*7BQ@)fWA~L$)#*LBi_wDq(PQ~PloK5cE}V#FSePu99_Kb#`Jf~e(@J@>dG0l z?k)jDMjbCuynb2xV%qM}&wBms4*4fAjBT36TSX7IfBh))#jOBPVDLwN6fgo+6s`VQX>&;;#E^P3A0OEidxdXF6Ku9-cqbhgl(JRXsb zwomPo$Ku(v8hjwLe@Lr6pUmOBw-fQjwyN(2c9MeCb@kiCFRdtg&)+ksZ?o4l?QgVO zgRM^BelI~LxUE;6xo<81nw}m{NzKiLl)+7Khz6Q7f$K_jumKgcMj@BQRW&4wEC&8!nGgL(cd z+z*(9)J)FF9w~-tH5S#awv;qo(+nwZ_8NfwO`G!KmV3*`%_kLI_|r!*uHPzSH(Amr zf54JnAI-!VFV=?-dmQtzZZ^h>*aW)jSyf8_ibghUYe~8x_iJx71`(3_ZZY&fS7v@h zND%y86B&~^Ji-WP7h}=475j|hf%M(=&QDm0?eaD9O)~24c{)LMj0}*wzuXn9oPB01 zhC*Mq*%&vc88(KN-OzF;4Z_Yr>OEAze_59fmhM2ReD*~`QhgCUIdGBQIUESdL$sf9 z3HfC3g59T)onI)%joY7F>B>N0yI467sf#@KV`PH2k-FD>=fKhc=wAs%*8<|sUR4ca zaH5bVK`vSjH!LorA}3$HRe68NC441@ZT8u7Y3o)p_k44{Ni5keSH3l zVEy``6AkpI{*X(cpbvV1O~C92e`bM1;d|nj7_0oXuU`T-mEHWva+k94wA}Y#Ek`X+D61u4%U?glAAbp-aKDmR5#d4BsDe?MTjFY%(UhQ`jq3vSKnmKf+5k|#h*i=$&d``=@ z&s`%gST_u~8zw4cfqK^`f5x+Y*?aDJ=Y~YxH%=|kD#Wl7klMn7-0#o0gwJ+;+L^^o z?Ry5y*HL3&OiNm&r}lSE<#jh$P$Nuc-1F5DimqFbKcQarIGr*>C-0YFV;1@KT|Ax) z^7xnRSj6MLe9&RPa6U`mYjseoeScgMk_+|r{u19A88K@4KAh6ae<~pJ?vY@?O9s1} z{ls~IWvv>09h$4*(?96pZ=ufh*LsqV@M88kRU_v9O8(y3H<0;`R<*O9_?K~E;`cqp z988I9!%LRi5mk?7YuUdL@Z?>nwc6XT+hw?Q6;NWRL9u6ul}wxvIYC;i$HzTf9$Te$2nsmz|3zv_5&_~ zyjE+5Tk$A*!IO`a`57qB4ew27>bO?hBjG2V2J}4LTxk_{x@4a{02~~io4Ze-vv!r9 z&Lr7U(xtP+Jdu6+En>rnSzqU|k}c};D|;v(M)=;vfRU^~0O0%urCo~=&y)2u?n%C@ zU;eu@_uAc&f0Y^LbR*vL`g@|;=TdnLcbe^+~apdn%y&`yC#Cr21&H(lme z=NB%Av)>q|1whNobybF8hEQ-fF+|1G2q67Ek(NVeZlA6ZWPhWuN>a+Hu zt}+WUe`{&sRo;{h7Qo34Hf0|hbQ}RE9OXK1aeiniRdB-FRRf_%)xA72FUZ)!RvquW5%h|Va)OO0O-8TAa}4s5f1MV!z*0Zs5>7WbxU^}r$8aAEMDTOM zy@^H3GVG>v0 zf9vbE^uCbW)}@XM4?utW9Hn&pRW}aZ-x@&|;m!9%V&jj&WRbo|N&0(EFV2Y7%0L->YlT~UL4e)0Xtl5qd3}yeuqno>HTFjdfp?pq%EGP(6b8e{ zqi>!QO!mpICn43E1oJE6gslL}U|z3_90&t*a3 zkdUkDXxdxndv)f}ueP9K;rFe%w@oRj?Yn(dRg}PXbhW5Hkb9tR0+ODB;ZmsP>v*(g z;dQ1|JDTB=r=KzBVav;khG~l0zW$oQ0^ZTFvW*_ie@*B}4A8m^9~b0tnM+R=&nucE^}Ew-W--Z)$F5p4L$Ht>4`!Su+>oM+Cdl0OlBL zMCEtD;KAzWB7!dTj&3K2asr?kx5);#p{4kU3Rdu#ICK=3l!49b7G4L=gN$_iQQ*{p zUo$}L!SSUfPCp0Kby!m6bMd1koi(JG<9<_zEYG&B ze4rSCH)r71)lW=mAH(Yx6cQuKxLPO0aQhxn9Xakb$}W(7>wXdkDcHC8DQ}E#U%{O2 zMiIiLeqoLVy}?#LM|T4wsi!?$H~ZkqUOQb+%RSefm$)OWZXVD`nnd1_e`?at`FKSk zI$jg9UYWsNP&Fy0%z1~OMN%|wmrG?*i=gC7^iJxo9xYjUq__4!D;?Px@Lz&dj(z@) zj-N-c^-SxRq%iIg0yPh|P5n7?FARQdQ-prDF zPAXx$`%}sZ)`+zh0=&?JgV@>D!h(Wa?80!D0R7J9j&8J1e!3$%qgJ@x=7aB>?u4WD z-uvhWLI@?8{UlJWd^)V@RfaQi)@SCF0XYbJ{cK6k;IW;J$CG&xoAQBGYy$2ABCBr& zbIq^3flU;o0KBVse~V|o^=yt{GiApVts9BA zApz+{4WcT%6zeFh3LwI17Py+jqQrsc`yPa&ef8(Hb0N_)<30)Afr(0ke zJv+a^yQ2kuY{qYps~(@i6%At|71WvQHL@O^o5+8viG9qa!y9}qIU2i z)7z$C1_imOPY0xLG_u#7dUWl9&5eJ2=dC4Ff?-~Ov?p^Y_?pB2t@@4^?!__gGR@rU zc#^#Rcuf~{%|TU!C^pG$l@dkks|mYC!_4dr{<3f3fBSgx170RrZ%u0yG`)}Xb5hs# zS^1TJwq9v1_>wqL(^$laP9YWF5vzgSmY;D6u~6sr>qY8H#gQ(~X7k}A$+<m;_G`$k758 z7*mMh2~`dZ5!ZVYh4EK)!Oysa-LjK$tm2r(0@!fuzkU5J9UDsB7>F7KN4?&DMUTOd zacPVM7Pj=0Ib`a=x1G?(I_oaS6}Vt#x$}E*)iH zMA0Z0l5LWW?DBTKMCk#rAV4HsMD)*9^ ze=F#@^p%2+|RT=G< z0IWcNC1`g-VV+nyW?Ok3Sp;Yl5zvK}f4RrObaJ|F9lBrpLWn|!xF~N9KC8a(5WL`U zZm5rXy2jL|)TQ0(ANmpR=LX>S`JnTG5ANNmZ^A$kW#?Q#uOn-(!u#Lth@G`NwKZzc zZlx&HAtUeJ`gv6V?Y5>XW%DsMjd5|GXs;%qB%l#MuJe?8^x9hUtnV}hE`lRwe?Kh0#372~!bw$)xEX^Qo*ZAS#MexYwX9eODqP)Zhp z;qD7!OngFs3?TIQQ&pWXGf61GRHXY5feK9RyuyhkCHo}Cvvcma+wJzfu3}R|4Mh~f zlAMR>AOx)!c~?Kn3nqh=(JQ=9f6H0X;z^11)#A(0QIqhY`1o$M{1P7nas=l3M}2J@ zKo@%G5lZhajyIin2y0fqcaMpY2CEQ)d{I~uvL$m_rev&NDIM7KJb3&cFWN#n3v@N1k?lxluB(eDc^58gbdT0#_Vto~#e|8*#B77Xe z@gVuINYxbT<>a=7H0DM6ZhoI8pa89k@mz1tK;n(9{||HLb|g!VV?mWb5PU!!0wnYo zq0OVN4xP4tJG;}_Rh1DWaE?2O9cD2?cNBQQoe2W&&F!sT7$Yf^aRQv8I7$)A;7SF< zi`fmsVS0WIlU%<6Sr2Elf3A&BZSwT}8ped<#sfW3dNtHAo;eLIe6T3zI9c3A31k(6 z`Hlu{fu?KFOKPaN?U1v&H2MD4lwh2s_q}It0HE{j#hq5au1}v++eZ)K7f~q^?rfR4 zWcZAQ^=Y&OV8TznWJqgdHT$6dbtznqX{sOF#GHa`0r@7+ko zBx5)|7v>^bXmXP&f2GdYV0)Or^#pc#$6Ni0FqG&7m2WNL1#{i#qhKXY-Ce&D;@i_$ z8*qX)zcE-8C{4JxxGV#*oI#e5(LYmE&&D95(^yRWt)Q^ka9kxTG<1tL3;(pOj)swA z34RA-zm5gHkJk;#s7|Si)x+NV%8U_oS~48d^ObLz(hLg~f1LW+tZyIZ%E@DoiO{EM zcRkpmZr`>Z;M=!JLk?YNYE=NB2^Kc>UR(E}axumVi@LW1t|)~#{=F&PmXE6W#yf~6 zqu4N&HR}Ld_{R-wowaKt+uD`le!ePvzh4Iug|jKMFUT*KQ`#|^d?;QW2k^)k8!Fv4d;6+RCv>8wXzdS&A&*;l^d-+93Z zShJV31Og%lY=_hGe$Nz_-2?(1e`+UM^ya!Gz@Nw&ITu-~?fuL#TE;=8`Tad>lf4^% zrhKY4)7-(g;L{t73}xOyP<#U7dvzXNhb~!*wJUh}jKfHpZv-t5IGS7`pmu&ffn%a`YEiz?jLGy)yVHpJcINbf=$&1797qa#@n!2Nv9W_OEae{2%mu2lw( z;7Klt5yxhJi9b>jm3%Lq4?DCLb4*qMJd|n}bnbN<4-AKL^N=Sl1rs;7v*#H{4w8Z^ zMdtl9#%P!AtCE#Xmm-PGD+UbXYwgn_a_jjXvfn_@yU@2B*~S=;-gg8fE2raNivu=; z1vGSZRm1LH4}#aNFK(_Nf2|-lBrOl$18|mC>mBa!_act3D+@H=y^U`@Msnm@1o#Jr z;ZZUEq$^d=;C=RX8gZW&OvV;_o=m2f-ZXvs*E?v16p%Lh9sv#LW*z z{Q%r<^F#Mp|Hj~vrXRI3(3HRSlo32uT>pOQsA2rIcg-L%QD)E*?cE0A)j1?4i8&WZ&+m|WT5D%7 z1(qug)Y=d(SwA8L7TY2=x4HW}-kSzBPe?9vHAA#}3oG}tL8JZ?= zw;R1YO|LWLo1VWv_3S6ZG#W#mkH4SZ8vxhUSE0>)0QJN-3^r(_2@1WAblUlV>>){W zW+A{w>`3}=e1w7`$})~tjUEzns(1&We=NQkyd5xGo6y0=sv;Osn*1paI4Bi9v(J&S z-Z>pe=Y8HLf2IKbELq`hIT2vrg50*>i5%@~oBzN^@N5-!$|v9b_l+%AkqB6xNF#T9 z3-~fu&5ftwoPL~_pGL$s(8=mn1$z8V+~r^#81=1%7wqilS#K~woOFenA^o84IKBeg z4}1i=q)VFse@->%#!8owsT;ceCm3eNpf1IZ~r&5n;J-*E~!fe!N#lU6{ zLn8Ksv)nD_DcaP*v6}4DRRZ&ZeJ+t7_y~P)LzX$}0iSt6F^7-@X>%M<%f=$Km9#Az z(i%#CygxL%aFf7k^g-9!9T1w)xy;6_#e}57Q5Mt^&u(W}JRc4ky^y`fZ+wJriVtmk z(JMFse*(Uryw=y^T1^4IO=^J6U-Ksid>g)>NYufjEn6o_l5mkS-P?zEtugELO<3+` z#JtHO6H<_O+jr0Szy`nZ5u|cX#E47?ilgg-sBx+68%~6={q({g^oX0s+)nQ8rd;GC zWt-m?^cX^fgtWLy>xIj0c4itlrU9HcFwr3Vf2xaz(qw*X^B?#KFfdx13-FBU`8?2M z_wo?!a#gZAb_Q&YXi(I?kA%V+O2;5V&deZX#8y{i5?|Q<7jsYH7tvu8R^7R($9+%Tr z8%D|_Zi@~%WWW+Vm(e>p2HreIMO)eqy79gjM4LRWgevCjxFE;u$wWMsX&YX>e~F$S z_y|(eBqv2!MhI(5>q=x4*YCJc6>WRFe;0=F-sgs4oEnelV_-Jv@_}%!lYC4TXw%DvGl9says5Q(|_Y5OuhUQ8=;TkGx>o=j{)Y&;fs$a7swPu<$(UN zu2Om)+g3H6j;9Zp1+c7cF&(xa0oxtVv zP4$>86FMrON36|$<0EW+{7*CXn>{pXDEhLwN9kh00!wsmZ~}Gl$BebU@Zvc86KwGo zKP1z?0rw{-81c?+@-U;CqRsP}f3x#Kvytu2TP*@9@%xRB5F~LbH&2b^h`o%Sdjg)O zcf%!5MHf*E1A9|n5G?4UJ1|puTWWEDglKvZH0)>swzY}po(D*VipSVHd9bbTKe6;)@_y`x` z`^H$sMu??)zt`vWf?Pt1e}8;{z6-Y;vr8FQvT-E3BjGuT^M=qFZ1&DwzslfkZf?cewav3q4M93`Ab01~&+X4EQWK-$S_zamutVL+b0mDkcA zv>dLhIgMlu7nrmD{$tMa!ATd9pMHECk4iuzzV`jPN%;!hdN=tzf~= zrDRp>i-j(T>TU1E7xi z;p3%0kIjN#6$e4l-}ngcTY%5){Sm}Z629mm*+!#3Mz<_ehMT$0(`L=}VLLBX0#qA~ zh1e8l?oC<>Ph!18e%orzf`7=!En!JVGe0Jb$S`;Sum8wLAnFFx)qJKd8d(6P!kA>Y zmm9u2v{OYY$>`!v2;9MgorPSZD8eW(??c@ty>B+wOn(nrlhwKBsNbLkJ@GzwAO2k# z{)#F;@DZ5sYitWz1Uo;o9As*`a0o-@cnTArjE%t;VyOu;v97(TGk?yKqjkFKjNWmU^P0Pw@@oLlcq zh?D-g(PPe?G;W9M1$DIfMa;EC=iAmUe9v_+inQ*eqKMaZR};!w%e6*~iB=C_TMGoD zgoj7W31+zr;{zeI`wrnZ6~-xjk7&Fq=^$eZ^@Xj&ZmakLW`D`-e_7-_K`!R0;cqg2Fse7HS1GgF88o^(B*o8uP%0u z2g2)Ku}+aGpMN08=2&2E0Dlx|*g09!(hMLsM6iQ*(Q$rav`jSCBZB|ffuGf^lL`^< zEH~El`Dt{qL9xz69C)7N&pm!OCQv3C1c1b4ta{kTsVrn4P!U&fsQEYO>1T8}%4pXu ze0!A&OG*kOf>sPJG4BoYyL9UXVM$b8?uH@W)+ZaG2Y-Zp%401M#M;+gA~s3p2nPh| z6Z8%4i06Ljsz3V^iwDSZ8fQ;0m)LzCVYH9>JwGFwI19um-S{&h#J^mcr#^{ zuu+YSHf`oyA4o_ge29<)-`O-POG zheARrS${py;`n*!r}N7y4nwV+YSiA@pI_2d%qTjpwRZVO!fAMG?P`yWzEK_X@pb4L zv$t`XZ(GS*ZLD@|HkY3G4-ZfyHC|kAK+c4}7B=4mh=omj>;pO!A|jI5k*s}~tiSYA z5f=-LZ4sei_$gjLi8*ZMZ%OC|eUI_b8#D4e7A+J@$uI72JOaY-tE+s6rb9^@T4do} zycdG3iEgTn7@u|0JUyKBj{VdUY z*qXtJSUWMJZz+l?Q9Era<~L*od(THB_5&d=nV&935yU>`hwwo^!~0%c?*)H7xgsc9 zYoYN^ZS^V`{*)yYv1Lm)y_@Xa>muC&z8c*mx3~wk!E) zRD(lNC^Yh%{7Pv70 z`$^6^${S0y!OS74mtH=aX~P8pGmpvg9FBnX%@2-=L|ZGcL>XxE|OS|8%$ z(6*d?4n|k*`MoJm-`8&xlH(d6;{D6PyjFJ-0z1?cVdKp=5SVXe;k(ypYEOS>vpDSC zzoPFbV&W~5)0)770YCQMb5e)?x+}jZRN`>-=hvHR@h~k~FOs-^@K?7zl)nb_en8^q zx6cRu+^u~xvs>hUc7<_C_U{3(?=(|d>mVQ?_Ix<_A2~}wdb;ptdQ_8y8)7)Z%Jnr`qK8_n=;oest-0atQri3@Nz_& zVR4BswoCIq7ZD?C! zbMj0qe`^Hi+UIZCj*b|-s4z$d#fqm2`6zYG*)Fo|!x=6+G7-ry4Gv-dt{5khZYJ7x z9h_73sf|Wh9uWZa|GD5V)o4FS;y+p1yy*)S3=i>w8nidL@93`ryzvlvG%o7$rHhp`9G4 zLTMOOCx2T!NS;{07>DS8z;3ToX^Z1_JLO z{*k4~_CJC~pp0waG-eNq5uaL->=QhFx-LCD@@~gb9U~_Xwg)iHWiMz@)s7+eyvd7rE#6xJfN&rTUb#FyuFvKDl`u zLr9M+WIvnWLAk3<{#cy$j&1&ByuprhjPl=AhH-7K#_<{_`iTNO;+xYHm!7FbkG;OY z-9z>1-sXQMAAiBZ5C$OX2&tV*Ng+jgQ#%5pr9=fr+&B|i3|3dBhTlyGw$z{0Ww9?x z=xXt`-;3ITytm0kR-TevqQ$5AKj?|wFKS|WcdqkeSdpOD^kO3KQMK?2ZjGwuo-V~(gI&B z^0KF~@VaWhifw4K^MuL8lYS0Yr?a0Dz46Kbw7k^rMpLeO&*}ts){s6;RE9Nw_1J&m zfy1PUs5d#)S;1crcNHS5ov2Sda=Qzh?cT3%#!+J9qEn?j@F`@MThn#-Hg_J|AFMmZ zrU5b=`Rt2MGPtx18Iv{@yf_|Bx%wvtm^>zXFdz`bQTDl%Iz>n7e}h_~%UA01t?Wtp zw=L`}d4eZJd(^VdnAUB%k1N%GhEnW$SU%&O*7*wIP=t?9Vr74z%_))TFiV#8xvW{h zWf6954y`jtKj(u`m$vfoU%PHjTB7Y1C8@LMd{LwBP`k2eveh`LX?8l_nAL1kaakZM zUM5Avv%g$Z=g-G6AMkZ9!~s6GXJ)CyJ*)P2O+=;TL=N%zmcDUlbsV^V@V@$u)F~Qg zjg)=nA2Azl66`l*Rz8gj$nKnpoolD2?eEmYVp-o?fHRs++67kaSzqs|6XR$QaspFn z5T;)@Sv;>3BR1U%1jwf+qp}wb;EP@~JW2z=UWTGj9ST}jmeN4af`FG>zF89wydzug zb>6YpiG>+-oVO;>bBrW^d}boFZ*FZNyC^gz!n((PXAkFGHwT)Jh-i~0*fQ9n=tYx2 zXPfj{CQy?-!IvPd3rDQy zyg8WQ4^CJu3)jfCTeLd^0PvXn-<|92RnA7W3DxQP8pbyk*y*i*?_}|#1BbZ=fD>-O zAUiqL(Ng+uk?#;a<-fi<%!oLVa~`fAkA|;@nf!IQ6~GjmDxBx!tRc<+<^a?2a|srY z5iN?ID(w$Dz;q6OROQ|$TRj2j@PV^xbtV};c~w`a&a#a-o;E;?zEz{K3Xh|T_@~L> z!AlvTr?XvNlMz|ClM2_LyW_%t7kqJnM@; z76;NTICuO`{)yv&zPw%Qp2Hvyayvc8I$kp~6qyjrBy#_Mk_F|~F1BWgGdGUJ-C51e zY@>Z_DLRtpFYnmWhHc8Xx;A$)`2s*OU^aQYZh6{1UzB14-E1_Lht3H*=W9@+pr%N4 zIZ(~s7(+l`>pTl}ta0Zz`avMY#tpFq(Z%ze(z-bH=MSCSzF(epoeep`$rp3T`Tp(yh@R_3kdr1YQ*-yQxe5=9c4=je+`n zgRe1v6ox;0Z)cT_o``2nPjO}T_`o5_rMCn4=8C8=Qrr{HFy2+XfixO zHD#`@CEGT!0h-nWqu-Nh=)^xZDac>!4m=%Q*5NL@cPF>opJp)=Uu1V-z9FG_yrVg^ zI$==xuCv{D{|tDpb6xoqE}+f)tQ_ysRQeQ9LD_bTcmrVr6h^*yZ9ZRfvNicc9*-G- zoLHmZu~u}(C1dRY5NsczEs3)a_iGnz*pAvxj}Hh$nL5~ix3=zN7K0KG#wzpnP@|*R zI`{LZm&+UiFMkbPueNva4EDEA$0IV0zTj)5AOmgT`bvJSVPs+^Lf2qF=cmBC=kh+= z8JWuU=}r_NjA2W>GqLBWwc3=mjYrS`!bBs_Hw!3s4$Q>mHAiD{m`YZ%I6M^F+NneY_@^f9nZ`_tlrw6X)^V$C<)p_!(MxUo}2~&B@KTObthhUq1{*dehQOy?8OQ&o(QP7NymgECeGwC@( z6`f^U(hHWow?i9}_2ILk_ng&LWcHMHCS@0J2!EPm{Ty+} zksb6Md0@bK_8gn(D=mGh)0*i7Tn77Ml{dcAw0zY37Z5D_&Qm9&4q-4R?o0SsY*IVS zcOexL_4LaxsJ6>5Xpe_!Wy#ngO_;hrKjTb%FT?gXbRmJe9~|NabuF6s?OnvP#hf;! znSbqJ9j)bHHaZxIOE19g`F6f;)O!siHB$1wiQBP7(G#a81(35_bd=Ty=LxLa_T}M) z$L-Ow-n-oSl;d=t%2|Zy%j9+Xs^tx!e>J0S@9n!_a=YHTPEGzE329GHp2rxcB^A9|OTEsKk1?pR${l%Pn)pzC)*- z_Zc^veOFD>Qu(0%3d#G-cDfC1+kho=5JR5Jq>ROZO||}AWnAmUSu1YvZnlYIJ%8Iw z;o<<8qd%5!j1w01B&Bh&6QY>PxcYpq^{f%PngBJi{BjZT_1V$9$3|~P$?;8L@jB4h zjyz+d(xBG23vCwrnBhPPury$%%zP$kGh3KwI?`HehoL=IzLRSbWd z3$Q(LQt;3Zo3-zx?ys=T;Xxb*7k}epgELm{;4fF>TXB_>hGNsILl9Y*)e@lLzl{(` ze52GcH9>n${%sBY)UA2eO^th{Aw!6`a~Zb2-e!I%X7&x=xUq;Nj`NX_&jO>wfx-hR z2vAN|0}TIQE%59n6J3?8b`SyL73@3-PV!5h-^S&}hHieJrIw;DWt-jv0Dn~1jgl|O zh%^w(5IwtSv_D!t`Owig#Mm9L(=ci6(@~!Z7yE-iuLg##k8Q>)_me|z2vk53i6AbTVY6p3mM%Uj*}Y&9 z@?c%At8;bgQy0dgfS>3wS$|9)e3t#HwMqgjP>VQFePbE!ilg98pVqNSc3L?0ceDOD zy~-@GU?+@eKJEIHHtr*GV$k%QEstd9Uv;>rz=ukRx9_`3g2(y(O;8x{Dm%OPbJsYN z(=~UtKd*cpxT$g8xgY+Y>FX=zVT5|3W}ae_$#dfHmU6^o8<{EA&42zLwfC*wZu{1E z9EIO_jlI{oey?7DOLo7<;KPkqs1XN60FKR_FSHRYwjHCsToXwrh$EGy*)Jq*UW7j1 zQrqy54=-w}R%e%utopWbIw*Fl=NHz&$VcC4zwUi3dytS@p8mm_J{#EOy4Pjey(60p zKy399Ny5C=H!f0232^oIor*vzxHJA8~75w<4gHSK@sGK_b zGNu3np2Qqfm$y8;+H1=7#|AS7c`BHcMKOsnsN55G@tf)G&3|_89dMJ&c|gOXTTE|@ zKWA8tkgj{2^EN{?XQ4<`_X)RZ5g{Hc8}(8~dvi1+zi?%i6?3na42TMU6VoPA&yHY2ViP@TqryM;_tNZVzb zuvB;;cLcU%a%7qi+oDqm748e1p+aKq7T*=x$GGr+umk&*!9Ku6F%D)XJDo*wzPjPJL{(tCY!2^IUr^O0szz(Vh?D#O z`&4U09UQalJn81$8zKW*fMF7C$Z|`HOU-q>K>H1bwt=wGik=V>3*+nI6 z^Fl1Ecar_)=YPKyOgD(j++=&_QAdbID$tY-nD%xb#^D2gq(Nv{2xh)>%h}3Eb)z8q zkkprfY-xYvM(6kQ@b-a`6Y~rwqeZ>(jkXj%fa9KA`@uG-J9fU$Kswk=*Ln5*h8h=` zMrr4=^^UpH2!U``SgdfmtifvLsUG~8mnI==p_e6&-hmP1azGM5s%|Qi^|Lr-Rggbgu@un_@-3*TaS4N!MMKnjr8Q=*XwVV?gw7>!o;b41 zLW4fmIjySaT6xc5Q}#W*0Hu8D4C3iIb0U8!c4OiRBIep+R165x-Lk*yG!lT|t^19W z2EJ~l0SgS*9gSYgUW^2Qgna?Cy&5Cv791J`8h>ZJP$_D@y))z5A?-3pIZ3o;E?LIj z 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 z

; + data: Data; + pluginArgs: PluginArgs; +}; +type PagesPluginFunction = Record, PluginArgs = unknown> = (context: EventPluginContext) => Response | Promise; +declare module "assets:*" { + export const onRequest: PagesFunction; +} +// Copyright (c) 2022-2023 Cloudflare, Inc. +// Licensed under the Apache 2.0 license found in the LICENSE file or at: +// https://opensource.org/licenses/Apache-2.0 +declare module "cloudflare:pipelines" { + export abstract class PipelineTransformationEntrypoint { + protected env: Env; + protected ctx: ExecutionContext; + constructor(ctx: ExecutionContext, env: Env); + /** + * run recieves an array of PipelineRecord which can be + * transformed and returned to the pipeline + * @param records Incoming records from the pipeline to be transformed + * @param metadata Information about the specific pipeline calling the transformation entrypoint + * @returns A promise containing the transformed PipelineRecord array + */ + public run(records: I[], metadata: PipelineBatchMetadata): Promise; + } + export type PipelineRecord = Record; + export type PipelineBatchMetadata = { + pipelineId: string; + pipelineName: string; + }; + export interface Pipeline { + /** + * The Pipeline interface represents the type of a binding to a Pipeline + * + * @param records The records to send to the pipeline + */ + send(records: T[]): Promise; + } +} +// PubSubMessage represents an incoming PubSub message. +// The message includes metadata about the broker, the client, and the payload +// itself. +// https://developers.cloudflare.com/pub-sub/ +interface PubSubMessage { + // Message ID + readonly mid: number; + // MQTT broker FQDN in the form mqtts://BROKER.NAMESPACE.cloudflarepubsub.com:PORT + readonly broker: string; + // The MQTT topic the message was sent on. + readonly topic: string; + // The client ID of the client that published this message. + readonly clientId: string; + // The unique identifier (JWT ID) used by the client to authenticate, if token + // auth was used. + readonly jti?: string; + // A Unix timestamp (seconds from Jan 1, 1970), set when the Pub/Sub Broker + // received the message from the client. + readonly receivedAt: number; + // An (optional) string with the MIME type of the payload, if set by the + // client. + readonly contentType: string; + // Set to 1 when the payload is a UTF-8 string + // https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_Toc3901063 + readonly payloadFormatIndicator: number; + // Pub/Sub (MQTT) payloads can be UTF-8 strings, or byte arrays. + // You can use payloadFormatIndicator to inspect this before decoding. + payload: string | Uint8Array; +} +// JsonWebKey extended by kid parameter +interface JsonWebKeyWithKid extends JsonWebKey { + // Key Identifier of the JWK + readonly kid: string; +} +interface RateLimitOptions { + key: string; +} +interface RateLimitOutcome { + success: boolean; +} +interface RateLimit { + /** + * Rate limit a request based on the provided options. + * @see https://developers.cloudflare.com/workers/runtime-apis/bindings/rate-limit/ + * @returns A promise that resolves with the outcome of the rate limit. + */ + limit(options: RateLimitOptions): Promise; +} +// Namespace for RPC utility types. Unfortunately, we can't use a `module` here as these types need +// to referenced by `Fetcher`. This is included in the "importable" version of the types which +// strips all `module` blocks. +declare namespace Rpc { + // Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s. + // TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`. + // For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to + // accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape) + export const __RPC_STUB_BRAND: '__RPC_STUB_BRAND'; + export const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND'; + export const __WORKER_ENTRYPOINT_BRAND: '__WORKER_ENTRYPOINT_BRAND'; + export const __DURABLE_OBJECT_BRAND: '__DURABLE_OBJECT_BRAND'; + export const __WORKFLOW_ENTRYPOINT_BRAND: '__WORKFLOW_ENTRYPOINT_BRAND'; + export interface RpcTargetBranded { + [__RPC_TARGET_BRAND]: never; + } + export interface WorkerEntrypointBranded { + [__WORKER_ENTRYPOINT_BRAND]: never; + } + export interface DurableObjectBranded { + [__DURABLE_OBJECT_BRAND]: never; + } + export interface WorkflowEntrypointBranded { + [__WORKFLOW_ENTRYPOINT_BRAND]: never; + } + export type EntrypointBranded = WorkerEntrypointBranded | DurableObjectBranded | WorkflowEntrypointBranded; + // Types that can be used through `Stub`s + export type Stubable = RpcTargetBranded | ((...args: any[]) => any); + // Types that can be passed over RPC + // The reason for using a generic type here is to build a serializable subset of structured + // cloneable composite types. This allows types defined with the "interface" keyword to pass the + // serializable check as well. Otherwise, only types defined with the "type" keyword would pass. + type Serializable = + // Structured cloneables + BaseType + // Structured cloneable composites + | Map ? Serializable : never, T extends Map ? Serializable : never> | Set ? Serializable : never> | ReadonlyArray ? Serializable : never> | { + [K in keyof T]: K extends number | string ? Serializable : never; + } + // Special types + | Stub + // Serialized as stubs, see `Stubify` + | Stubable; + // Base type for all RPC stubs, including common memory management methods. + // `T` is used as a marker type for unwrapping `Stub`s later. + interface StubBase extends Disposable { + [__RPC_STUB_BRAND]: T; + dup(): this; + } + export type Stub = Provider & StubBase; + // This represents all the types that can be sent as-is over an RPC boundary + type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | ReadableStream | WritableStream | Request | Response | Headers; + // Recursively rewrite all `Stubable` types with `Stub`s + // prettier-ignore + type Stubify = T extends Stubable ? Stub : T extends Map ? Map, Stubify> : T extends Set ? Set> : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends BaseType ? T : T extends { + [key: string | number]: any; + } ? { + [K in keyof T]: Stubify; + } : T; + // Recursively rewrite all `Stub`s with the corresponding `T`s. + // Note we use `StubBase` instead of `Stub` here to avoid circular dependencies: + // `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`. + // prettier-ignore + type Unstubify = T extends StubBase ? V : T extends Map ? Map, Unstubify> : T extends Set ? Set> : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends BaseType ? T : T extends { + [key: string | number]: unknown; + } ? { + [K in keyof T]: Unstubify; + } : T; + type UnstubifyAll = { + [I in keyof A]: Unstubify; + }; + // Utility type for adding `Provider`/`Disposable`s to `object` types only. + // Note `unknown & T` is equivalent to `T`. + type MaybeProvider = T extends object ? Provider : unknown; + type MaybeDisposable = T extends object ? Disposable : unknown; + // Type for method return or property on an RPC interface. + // - Stubable types are replaced by stubs. + // - Serializable types are passed by value, with stubable types replaced by stubs + // and a top-level `Disposer`. + // Everything else can't be passed over PRC. + // Technically, we use custom thenables here, but they quack like `Promise`s. + // Intersecting with `(Maybe)Provider` allows pipelining. + // prettier-ignore + type Result = R extends Stubable ? Promise> & Provider : R extends Serializable ? Promise & MaybeDisposable> & MaybeProvider : never; + // Type for method or property on an RPC interface. + // For methods, unwrap `Stub`s in parameters, and rewrite returns to be `Result`s. + // Unwrapping `Stub`s allows calling with `Stubable` arguments. + // For properties, rewrite types to be `Result`s. + // In each case, unwrap `Promise`s. + type MethodOrProperty = V extends (...args: infer P) => infer R ? (...args: UnstubifyAll