From 79f11aa3b4acf3aef97beb2f6c53b7948a78993c Mon Sep 17 00:00:00 2001 From: Matthew Podwysocki Date: Mon, 5 Jan 2026 22:28:44 -0500 Subject: [PATCH 1/8] Add Map Matching and Optimization tools MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implements two new Mapbox Navigation API tools: - Map Matching Tool (map_matching_tool): Snaps GPS traces to roads - Supports 2-100 coordinates with optional timestamps and radiuses - Returns confidence scores, matched geometry, and annotations - Handles driving, cycling, walking, and driving-traffic profiles - Optimization Tool (optimization_tool): Solves vehicle routing problems - Supports up to 1000 coordinates - Simplified mode: auto-generates vehicle and services - Advanced mode: custom vehicles, services, shipments, time windows - Async polling mechanism (POST + GET) Both tools include: - Complete input/output schemas with Zod validation - Comprehensive unit tests (19 tests total) - Proper annotations (readOnlyHint, openWorldHint, etc.) All 422 tests passing. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 --- .../MapMatchingTool.input.schema.ts | 74 +++ .../MapMatchingTool.output.schema.ts | 56 ++ .../map-matching-tool/MapMatchingTool.ts | 155 ++++++ .../OptimizationTool.input.schema.ts | 212 ++++++++ .../OptimizationTool.output.schema.ts | 139 +++++ .../optimization-tool/OptimizationTool.ts | 305 +++++++++++ src/tools/toolRegistry.ts | 4 + .../map-matching-tool/MapMatchingTool.test.ts | 248 +++++++++ .../OptimizationTool.test.ts | 478 ++++++++++++++++++ 9 files changed, 1671 insertions(+) create mode 100644 src/tools/map-matching-tool/MapMatchingTool.input.schema.ts create mode 100644 src/tools/map-matching-tool/MapMatchingTool.output.schema.ts create mode 100644 src/tools/map-matching-tool/MapMatchingTool.ts create mode 100644 src/tools/optimization-tool/OptimizationTool.input.schema.ts create mode 100644 src/tools/optimization-tool/OptimizationTool.output.schema.ts create mode 100644 src/tools/optimization-tool/OptimizationTool.ts create mode 100644 test/tools/map-matching-tool/MapMatchingTool.test.ts create mode 100644 test/tools/optimization-tool/OptimizationTool.test.ts diff --git a/src/tools/map-matching-tool/MapMatchingTool.input.schema.ts b/src/tools/map-matching-tool/MapMatchingTool.input.schema.ts new file mode 100644 index 0000000..6ad43df --- /dev/null +++ b/src/tools/map-matching-tool/MapMatchingTool.input.schema.ts @@ -0,0 +1,74 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; +import { coordinateSchema } from '../../schemas/shared.js'; + +export const MapMatchingInputSchema = z.object({ + coordinates: z + .array(coordinateSchema) + .min(2, 'At least two coordinate pairs are required.') + .max(100, 'Up to 100 coordinate pairs are supported.') + .describe( + 'Array of coordinate objects with longitude and latitude properties representing a GPS trace. ' + + 'Must include at least 2 and up to 100 coordinate pairs. ' + + 'Coordinates should be in the order they were recorded.' + ), + profile: z + .enum(['driving', 'driving-traffic', 'walking', 'cycling']) + .default('driving') + .describe( + 'Routing profile for different modes of transport. Options: \n' + + '- driving: automotive based on road network\n' + + '- driving-traffic: automotive with current traffic conditions\n' + + '- walking: pedestrian/hiking\n' + + '- cycling: bicycle' + ), + timestamps: z + .array(z.number().int().positive()) + .optional() + .describe( + 'Array of Unix timestamps (in seconds) corresponding to each coordinate. ' + + 'If provided, must have the same length as coordinates array. ' + + 'Used to improve matching accuracy based on speed.' + ), + radiuses: z + .array(z.number().min(0)) + .optional() + .describe( + 'Array of maximum distances (in meters) each coordinate can snap to the road network. ' + + 'If provided, must have the same length as coordinates array. ' + + 'Default is unlimited. Use smaller values (5-25m) for high-quality GPS, ' + + 'larger values (50-100m) for noisy GPS traces.' + ), + annotations: z + .array(z.enum(['speed', 'distance', 'duration', 'congestion'])) + .optional() + .describe( + 'Additional data to include in the response. Options: \n' + + '- speed: Speed limit per segment (km/h)\n' + + '- distance: Distance per segment (meters)\n' + + '- duration: Duration per segment (seconds)\n' + + '- congestion: Traffic level per segment (low, moderate, heavy, severe)' + ), + overview: z + .enum(['full', 'simplified', 'false']) + .default('full') + .describe( + 'Format of the returned geometry. Options: \n' + + '- full: Returns full geometry with all points\n' + + '- simplified: Returns simplified geometry\n' + + '- false: No geometry returned' + ), + geometries: z + .enum(['geojson', 'polyline', 'polyline6']) + .default('geojson') + .describe( + 'Format of the returned geometry. Options: \n' + + '- geojson: GeoJSON LineString (recommended)\n' + + '- polyline: Polyline with precision 5\n' + + '- polyline6: Polyline with precision 6' + ) +}); + +export type MapMatchingInput = z.infer; diff --git a/src/tools/map-matching-tool/MapMatchingTool.output.schema.ts b/src/tools/map-matching-tool/MapMatchingTool.output.schema.ts new file mode 100644 index 0000000..4288514 --- /dev/null +++ b/src/tools/map-matching-tool/MapMatchingTool.output.schema.ts @@ -0,0 +1,56 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +// GeoJSON LineString schema +const GeoJSONLineStringSchema = z.object({ + type: z.literal('LineString'), + coordinates: z.array( + z + .tuple([z.number(), z.number()]) + .or(z.tuple([z.number(), z.number(), z.number()])) + ) +}); + +// Tracepoint schema - represents a snapped coordinate +const TracepointSchema = z.object({ + name: z.string().optional(), + location: z.tuple([z.number(), z.number()]), + waypoint_index: z.number().optional(), + matchings_index: z.number(), + alternatives_count: z.number() +}); + +// Matching schema - represents a matched route +const MatchingSchema = z.object({ + confidence: z.number().min(0).max(1), + distance: z.number(), + duration: z.number(), + geometry: z.union([GeoJSONLineStringSchema, z.string()]), + legs: z + .array( + z.object({ + distance: z.number(), + duration: z.number(), + annotation: z + .object({ + speed: z.array(z.number()).optional(), + distance: z.array(z.number()).optional(), + duration: z.array(z.number()).optional(), + congestion: z.array(z.string()).optional() + }) + .optional() + }) + ) + .optional() +}); + +// Main output schema +export const MapMatchingOutputSchema = z.object({ + code: z.string(), + matchings: z.array(MatchingSchema), + tracepoints: z.array(TracepointSchema.nullable()) +}); + +export type MapMatchingOutput = z.infer; diff --git a/src/tools/map-matching-tool/MapMatchingTool.ts b/src/tools/map-matching-tool/MapMatchingTool.ts new file mode 100644 index 0000000..a5dd95e --- /dev/null +++ b/src/tools/map-matching-tool/MapMatchingTool.ts @@ -0,0 +1,155 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { URLSearchParams } from 'node:url'; +import type { z } from 'zod'; +import { MapboxApiBasedTool } from '../MapboxApiBasedTool.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; +import { MapMatchingInputSchema } from './MapMatchingTool.input.schema.js'; +import { + MapMatchingOutputSchema, + type MapMatchingOutput +} from './MapMatchingTool.output.schema.js'; +import type { HttpRequest } from '../../utils/types.js'; + +// Docs: https://docs.mapbox.com/api/navigation/map-matching/ + +export class MapMatchingTool extends MapboxApiBasedTool< + typeof MapMatchingInputSchema, + typeof MapMatchingOutputSchema +> { + name = 'map_matching_tool'; + description = + 'Snap GPS traces to roads using Mapbox Map Matching API. Takes noisy/inaccurate ' + + 'coordinate sequences (2-100 points) and returns clean routes aligned with actual ' + + 'roads, bike paths, or walkways. Useful for analyzing recorded trips, cleaning ' + + 'fleet tracking data, or processing fitness activity traces. Returns confidence ' + + 'scores, matched geometry, and optional traffic/speed annotations.'; + annotations = { + title: 'Map Matching Tool', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: true + }; + + constructor(params: { httpRequest: HttpRequest }) { + super({ + inputSchema: MapMatchingInputSchema, + outputSchema: MapMatchingOutputSchema, + httpRequest: params.httpRequest + }); + } + + protected async execute( + input: z.infer, + accessToken: string + ): Promise { + // Validate timestamps array length matches coordinates + if ( + input.timestamps && + input.timestamps.length !== input.coordinates.length + ) { + return { + content: [ + { + type: 'text', + text: 'The timestamps array must have the same length as the coordinates array' + } + ], + isError: true + }; + } + + // Validate radiuses array length matches coordinates + if (input.radiuses && input.radiuses.length !== input.coordinates.length) { + return { + content: [ + { + type: 'text', + text: 'The radiuses array must have the same length as the coordinates array' + } + ], + isError: true + }; + } + + // Build coordinate string: "lon1,lat1;lon2,lat2;..." + const coordsString = input.coordinates + .map((coord) => `${coord.longitude},${coord.latitude}`) + .join(';'); + + // Build query parameters + const queryParams = new URLSearchParams(); + queryParams.append('access_token', accessToken); + queryParams.append('geometries', input.geometries); + queryParams.append('overview', input.overview); + + // Add timestamps if provided (semicolon-separated) + if (input.timestamps) { + queryParams.append('timestamps', input.timestamps.join(';')); + } + + // Add radiuses if provided (semicolon-separated) + if (input.radiuses) { + queryParams.append('radiuses', input.radiuses.join(';')); + } + + // Add annotations if provided (comma-separated) + if (input.annotations && input.annotations.length > 0) { + queryParams.append('annotations', input.annotations.join(',')); + } + + const url = `${MapboxApiBasedTool.mapboxApiEndpoint}matching/v5/mapbox/${input.profile}/${coordsString}?${queryParams.toString()}`; + + const response = await this.httpRequest(url); + + if (!response.ok) { + const errorText = await response.text(); + let errorMessage = `Request failed with status ${response.status}: ${response.statusText}`; + + try { + const errorJson = JSON.parse(errorText); + if (errorJson.message) { + errorMessage = `${errorMessage} - ${errorJson.message}`; + } + } catch { + if (errorText) { + errorMessage = `${errorMessage} - ${errorText}`; + } + } + + return { + content: [{ type: 'text', text: errorMessage }], + isError: true + }; + } + + const data = (await response.json()) as MapMatchingOutput; + + // Validate the response against our output schema + try { + const validatedData = MapMatchingOutputSchema.parse(data); + + return { + content: [ + { type: 'text', text: JSON.stringify(validatedData, null, 2) } + ], + structuredContent: validatedData, + isError: false + }; + } catch (validationError) { + // If validation fails, return the raw result anyway with a warning + this.log( + 'warning', + `Schema validation warning: ${validationError instanceof Error ? validationError.message : String(validationError)}` + ); + + return { + content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], + structuredContent: data, + isError: false + }; + } + } +} diff --git a/src/tools/optimization-tool/OptimizationTool.input.schema.ts b/src/tools/optimization-tool/OptimizationTool.input.schema.ts new file mode 100644 index 0000000..ca4b2bb --- /dev/null +++ b/src/tools/optimization-tool/OptimizationTool.input.schema.ts @@ -0,0 +1,212 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; +import { coordinateSchema } from '../../schemas/shared.js'; + +// Profile schema (driving, walking, cycling, driving-traffic) +const profileSchema = z + .enum([ + 'mapbox/driving', + 'mapbox/walking', + 'mapbox/cycling', + 'mapbox/driving-traffic' + ]) + .describe('Routing profile'); + +// * Input schema for OptimizationTool (Minimal) +// * +// * Accepts an array of coordinates and a routing profile. +// * The tool internally converts this to the full Optimization API v2 request format. + +const optionsSchema = z.object({ + objectives: z + .array( + z.enum(['min-total-travel-duration', 'min-schedule-completion-time']) + ) + .optional() + .describe('Optimization objectives') +}); + +const iso8601Schema = z + .string() + .regex( + /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?([+-]\d{2}:\d{2}|Z)?$/, + 'Must be a valid ISO 8601 datetime string (e.g., 2023-07-22T14:29:23-07:00)' + ); + +const timeWindowSchema = z.object({ + earliest: iso8601Schema.describe('Earliest time for this window'), + latest: iso8601Schema.describe('Latest time for this window'), + type: z + .enum(['strict', 'soft', 'soft_start', 'soft_end']) + .optional() + .describe('Type of time window constraint') +}); + +const vehicleBreakSchema = z.object({ + earliest_start: iso8601Schema.describe('Earliest start time for break'), + latest_end: iso8601Schema.describe('Latest end time for break'), + duration: z.number().int().positive().describe('Break duration in seconds') +}); + +const vehicleSchema = z.object({ + name: z.string().describe('Unique identifier for this vehicle'), + routing_profile: profileSchema + .optional() + .describe('Routing profile for this vehicle'), + start_location: z + .string() + .optional() + .describe( + 'Starting location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' + ), + end_location: z + .string() + .optional() + .describe( + 'Ending location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' + ), + capacities: z + .record(z.number()) + .optional() + .describe('Custom capacity dimensions (e.g., weight, volume)'), + capabilities: z + .array(z.string()) + .optional() + .describe('Required vehicle capabilities'), + earliest_start: iso8601Schema + .optional() + .describe('Earliest operation start time'), + latest_end: iso8601Schema.optional().describe('Latest operation end time'), + breaks: z + .array(vehicleBreakSchema) + .optional() + .describe('Vehicle break requirements'), + loading_policy: z + .enum(['any', 'fifo', 'lifo']) + .optional() + .describe('Loading/unloading policy') +}); + +const serviceSchema = z.object({ + name: z.string().describe('Unique identifier for this service'), + location: z + .string() + .describe( + 'Location as a STRING name where service is performed. Use "location-0" for coordinates[0], "location-1" for coordinates[1], etc. (NOT integers like 0, 1, 2)' + ), + duration: z + .number() + .int() + .nonnegative() + .optional() + .default(0) + .describe('Service duration in seconds'), + requirements: z + .array(z.string()) + .optional() + .describe('Required vehicle capabilities'), + service_times: z + .array(timeWindowSchema) + .optional() + .describe('Time window constraints for service') +}); + +const shipmentSchema = z.object({ + name: z.string().describe('Unique identifier for this shipment'), + from: z + .string() + .describe( + 'Pickup location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' + ), + to: z + .string() + .describe( + 'Delivery location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' + ), + size: z + .record(z.number()) + .optional() + .describe('Capacity consumption (weight, volume, etc.)'), + requirements: z + .array(z.string()) + .optional() + .describe('Required vehicle capabilities'), + pickup_duration: z + .number() + .int() + .nonnegative() + .optional() + .default(0) + .describe('Pickup duration in seconds'), + dropoff_duration: z + .number() + .int() + .nonnegative() + .optional() + .default(0) + .describe('Dropoff duration in seconds'), + pickup_times: z + .array(timeWindowSchema) + .optional() + .describe('Time window constraints for pickup'), + dropoff_times: z + .array(timeWindowSchema) + .optional() + .describe('Time window constraints for dropoff') +}); + +export const OptimizationInputSchema = z.object({ + coordinates: z + .array(coordinateSchema) + .min(2, 'At least 2 coordinates are required') + .max(1000, 'Maximum 1000 coordinates allowed') + .describe( + 'Array of {longitude, latitude} coordinate pairs to optimize a route through. ' + + 'Must include at least 2 coordinate pairs. ' + + 'Up to 1000 coordinates total are supported.' + ), + profile: profileSchema + .optional() + .default('mapbox/driving') + .describe('Routing profile to use for optimization'), + vehicles: z + .array(vehicleSchema) + .optional() + .describe( + 'Array of vehicle objects. If not provided, a default vehicle will be created automatically. ' + + 'IMPORTANT: If you provide vehicles, you MUST also provide either "services" or "shipments" to define the stops each vehicle should visit.' + ), + services: z + .array(serviceSchema) + .optional() + .describe( + 'Array of service objects representing individual stops/tasks (e.g., deliveries, pickups, visits). ' + + 'Each service is performed at a single location. Required when using custom vehicles.' + ), + shipments: z + .array(shipmentSchema) + .optional() + .describe( + 'Array of shipment objects representing paired pickup/delivery tasks. ' + + 'Each shipment has a pickup location and a delivery location. Can be used with or instead of services when using custom vehicles.' + ), + options: optionsSchema.optional().describe('Optimization options'), + max_polling_attempts: z + .number() + .int() + .positive() + .optional() + .default(30) + .describe('Maximum number of polling attempts (default: 30)'), + polling_interval_ms: z + .number() + .int() + .positive() + .optional() + .default(1000) + .describe('Polling interval in milliseconds (default: 1000)') +}); + +export type OptimizationInput = z.infer; diff --git a/src/tools/optimization-tool/OptimizationTool.output.schema.ts b/src/tools/optimization-tool/OptimizationTool.output.schema.ts new file mode 100644 index 0000000..99614f6 --- /dev/null +++ b/src/tools/optimization-tool/OptimizationTool.output.schema.ts @@ -0,0 +1,139 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Stop schema for route stops + * Made flexible to handle various API response formats + */ +const stopSchema = z + .object({ + type: z + .string() + .describe( + 'Type of stop. Known values include "start" (vehicle begins), "service" (perform service), "pickup"/"dropoff" (shipment handling), "break" (vehicle break), "end" (vehicle finishes). Additional values may be returned as the API evolves.' + ), + location: z + .string() + .describe( + 'Location name for this stop (e.g., "location-0", "location-1")' + ), + eta: z + .string() + .optional() + .describe( + 'Estimated time of arrival in ISO 8601 format (e.g., "2023-07-22T14:29:23-07:00")' + ), + odometer: z + .number() + .optional() + .describe('Total distance traveled to reach this stop in meters'), + wait: z + .number() + .optional() + .describe('Wait time at this stop in seconds before proceeding'), + duration: z + .number() + .optional() + .describe('Duration of service/activity at this stop in seconds'), + services: z + .array(z.string()) + .optional() + .describe('Array of service names fulfilled at this stop'), + pickups: z + .array(z.string()) + .optional() + .describe('Array of shipment names picked up at this stop'), + dropoffs: z + .array(z.string()) + .optional() + .describe('Array of shipment names dropped off at this stop') + }) + .passthrough(); // Allow additional fields from API + +/** + * Route schema + */ +const routeSchema = z + .object({ + vehicle: z + .string() + .describe( + 'Vehicle name for this route (matches the vehicle name from input)' + ), + stops: z + .array(stopSchema) + .describe( + 'Ordered sequence of stops for this vehicle, from start to end. Includes all services, pickups, dropoffs, and breaks in optimized order.' + ) + }) + .passthrough(); // Allow additional fields from API + +/** + * Dropped items schema + */ +const droppedSchema = z + .object({ + services: z + .array(z.string()) + .optional() + .describe( + 'Array of service names that could not be fulfilled due to constraints (e.g., time windows, capacity, capabilities)' + ), + shipments: z + .array(z.string()) + .optional() + .describe( + 'Array of shipment names that could not be fulfilled due to constraints (e.g., time windows, capacity, capabilities)' + ) + }) + .passthrough(); // Allow additional fields from API + +/** + * Output schema for OptimizationTool + * Uses passthrough to be flexible with API response variations + */ +export const OptimizationOutputSchema = z + .object({ + version: z + .number() + .optional() + .describe('API version number (always 1 for Optimization API v2)'), + dropped: droppedSchema + .optional() + .describe( + 'Items that could not be fulfilled in the optimization. If present, contains arrays of service/shipment names that were dropped.' + ), + routes: z + .array(routeSchema) + .optional() + .describe( + 'Array of optimized routes, one per vehicle. Each route contains the vehicle name and an ordered sequence of stops. May be undefined if optimization fails completely.' + ), + // Error response fields from API + code: z + .string() + .optional() + .describe( + 'Error code from API (e.g., "internal_error"). Present only when the API returns an error response.' + ), + message: z + .string() + .optional() + .describe( + 'Human-readable error message from API. Present only when the API returns an error response.' + ), + ref: z + .string() + .optional() + .describe( + 'Reference ID for the error from API. Present only when the API returns an error response.' + ) + }) + .passthrough(); // Allow additional fields from API + +/** + * Type inference for OptimizationOutput + */ +export type OptimizationOutput = z.infer; diff --git a/src/tools/optimization-tool/OptimizationTool.ts b/src/tools/optimization-tool/OptimizationTool.ts new file mode 100644 index 0000000..368b02c --- /dev/null +++ b/src/tools/optimization-tool/OptimizationTool.ts @@ -0,0 +1,305 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import type { z } from 'zod'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; +import { MapboxApiBasedTool } from '../MapboxApiBasedTool.js'; +import type { HttpRequest } from '../../utils/types.js'; +import { OptimizationInputSchema } from './OptimizationTool.input.schema.js'; +import { + OptimizationOutputSchema, + type OptimizationOutput +} from './OptimizationTool.output.schema.js'; + +// API documentation: https://docs.mapbox.com/api/navigation/optimization/ + +/** + * OptimizationTool - Solves vehicle routing problems using the Mapbox Optimization API v2. + * Supports complex routing scenarios with multiple vehicles, time windows, capacities, and shipments. + */ +export class OptimizationTool extends MapboxApiBasedTool< + typeof OptimizationInputSchema, + typeof OptimizationOutputSchema +> { + name = 'optimization_tool'; + description = + 'Solves vehicle routing problems using the Mapbox Optimization API v2. ' + + 'Supports up to 1000 coordinates in {longitude, latitude} format. ' + + 'Returns optimized routes with stops, ETAs, and dropped items. ' + + '\n\n' + + 'USAGE MODES:\n' + + '1. SIMPLIFIED MODE (recommended for basic routing): Provide only "coordinates" and optionally "profile". ' + + 'The tool will automatically create a default vehicle that visits all locations in optimized order, ' + + 'starting and ending at the first coordinate.\n' + + '2. ADVANCED MODE (for complex scenarios): If you specify "vehicles", you MUST also provide either ' + + '"services" (single stops like deliveries or pickups) or "shipments" (paired pickup/dropoff tasks). ' + + 'Each service/shipment defines a stop that vehicles must visit.\n' + + '\n' + + 'KEY CONCEPTS:\n' + + '- "services": Individual stops at locations (e.g., deliver package to address A, pick up at coffee shop B)\n' + + '- "shipments": Paired pickup/delivery tasks (e.g., pick up from warehouse, deliver to customer)\n' + + '- "vehicles": Routing agents with optional constraints like time windows, capacities, and capabilities\n' + + '\n' + + 'LOCATION NAMING (CRITICAL):\n' + + 'The tool auto-generates STRING location names from your coordinates array as "location-0", "location-1", "location-2", etc. ' + + 'When creating services, shipments, or vehicles, you MUST reference these auto-generated STRINGS (NOT integers, NOT array indices):\n' + + '- coordinates[0] → use STRING "location-0" (NOT integer 0)\n' + + '\n' + + 'EXAMPLES:\n' + + '✓ CORRECT: service.location = "location-2" (string)\n' + + '✗ WRONG: service.location = 2 (integer)\n' + + '\n' + + 'OUTPUT FORMAT:\n' + + 'The tool returns a solution with:\n' + + '- "routes": Array of optimized routes, one per vehicle. Each route contains:\n' + + ' - "vehicle": The vehicle name\n' + + ' - "stops": Ordered array of stops with:\n' + + ' - "type": start, service, pickup, dropoff, break, or end\n' + + ' - "location": The location name (e.g., "location-0")\n' + + ' - "eta": Estimated time of arrival (ISO 8601 timestamp)\n' + + ' - "odometer": Total distance traveled in meters\n' + + ' - "wait": Wait time in seconds before proceeding\n' + + ' - "duration": Service time in seconds\n' + + ' - "services": Array of service names fulfilled at this stop\n' + + ' - "pickups"/"dropoffs": Arrays of shipment names handled\n' + + '- "dropped": Object with "services" and "shipments" arrays listing items that could not be fulfilled\n' + + '\n' + + 'WORKING WITH RESPONSES:\n' + + 'The tool returns structured data that you can access directly as an object/dictionary. ' + + 'DO NOT try to parse the response as a JSON string - access it as structured data instead. ' + + 'For large responses: (1) Access routes directly: result.routes[0], result.routes[1], etc. ' + + '(2) Iterate through routes: for route in result.routes. ' + + '(3) Access stop data: route.stops[i].location, route.stops[i].eta, etc. ' + + '(4) Extract only the fields you need rather than copying the entire response. ' + + 'NEVER use JSON.parse() or string manipulation on the response - the data is already structured and ready to use.\n' + + '\n' + + 'PRESENTING RESULTS TO USERS:\n' + + 'When sharing optimization results, ALWAYS present the route assignments. For each route, show: ' + + '(1) The vehicle name/ID. ' + + '(2) The complete ordered list of stops for that vehicle (by location name or service name). Include ALL routes. ' + + '(3) Key metrics like total distance, number of stops, and all ETAs. ' + + 'Example format: "Vehicle 1 route: Depot (location-0) → Coffee Shop A (location-1) → Coffee Shop B (location-5) → Depot (location-0). Total: 3 stops, 15.2 km." ' + + '\n' + + 'DISPLAYING ROUTES ON A MAP:\n' + + 'The optimization API returns the SEQUENCE of stops but NOT route geometries (line paths between stops). ' + + 'To draw routes on a map: (1) Extract the ordered stop locations from each route. ' + + '(2) For each consecutive pair of stops, use a routing/directions API to get the path geometry between them. ' + + '(3) Combine these geometries to visualize the complete route path. ' + + 'You can display stop markers immediately, but drawing connecting route lines requires additional routing API calls.\n' + + 'When building the map in the final_answer, include all the generated routes in a list like [vehicle1_route, vehicle2_route], and include all the stops as points on the map.' + + '\n' + + 'IMPORTANT: Coordinates must be {longitude, latitude} objects where longitude comes first.'; + annotations = { + title: 'Optimization Tool', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: false, + openWorldHint: true + }; + + constructor({ httpRequest }: { httpRequest: HttpRequest }) { + super({ + inputSchema: OptimizationInputSchema, + outputSchema: OptimizationOutputSchema, + httpRequest + }); + } + + /** + * Execute the tool logic + * @param input - Validated input from OptimizationInputSchema + * @param accessToken - Mapbox access token + * @returns CallToolResult with structured output + */ + protected async execute( + input: z.infer, + accessToken: string + ): Promise { + // Validate: If vehicles are provided, at least one service or shipment is required + if (input.vehicles && input.vehicles.length > 0) { + const hasServices = input.services && input.services.length > 0; + const hasShipments = input.shipments && input.shipments.length > 0; + + if (!hasServices && !hasShipments) { + return { + content: [ + { + type: 'text', + text: JSON.stringify({ + error: + 'When vehicles are provided, at least one service or shipment is required' + }) + } + ], + isError: true + }; + } + } + + // Convert simplified input to Optimization API v2 format + // Create locations array with auto-generated names + const locations = input.coordinates.map((coord, index) => ({ + name: `location-${index}`, + coordinates: [coord.longitude, coord.latitude] as [number, number] + })); + + // If vehicles are not provided, create a default vehicle + let vehicles: Array; + let services: Array; + let shipments: Array | undefined; + + if (!input.vehicles || input.vehicles.length === 0) { + // Simplified mode: auto-generate vehicle and services from coordinates + vehicles = [ + { + name: 'vehicle-1', + routing_profile: input.profile, + start_location: 'location-0', // Start at first location + end_location: 'location-0' // Return to first location + } + ]; + + // Create services for all locations except the first (which is start/end) + services = input.coordinates.slice(1).map((_, index) => ({ + name: `service-${index + 1}`, + location: `location-${index + 1}`, + duration: 0 // No service time by default + })); + } else { + // Advanced mode: use provided vehicles, services, and shipments + vehicles = input.vehicles; + services = input.services || []; + shipments = input.shipments; + } + + // Build request body + const requestBody: { + version: number; + locations: Array<{ name: string; coordinates: [number, number] }>; + vehicles: Array; + services: Array; + shipments?: Array; + } = { + version: 1, + locations, + vehicles, + services + }; + + if (shipments && shipments.length > 0) { + requestBody.shipments = shipments; + } + + // Step 1: POST to create optimization job + const postUrl = `${MapboxApiBasedTool.mapboxApiEndpoint}optimized-trips/v2?access_token=${accessToken}`; + + const postResponse = await this.httpRequest(postUrl, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify(requestBody) + }); + + if (!postResponse.ok) { + const errorText = await postResponse.text(); + let errorMessage = `Request failed with status ${postResponse.status}: ${postResponse.statusText}`; + + try { + const errorJson = JSON.parse(errorText); + if (errorJson.message) { + errorMessage = `${errorMessage} - ${errorJson.message}`; + } + } catch { + // If parsing fails, use the raw text + if (errorText) { + errorMessage = `${errorMessage} - ${errorText}`; + } + } + + return { + content: [{ type: 'text', text: errorMessage }], + isError: true + }; + } + + const postData = (await postResponse.json()) as { + id: string; + status: string; + }; + const jobId = postData.id; + + // Step 2: Poll GET endpoint for results + const maxAttempts = input.max_polling_attempts ?? 10; + const pollingInterval = input.polling_interval_ms ?? 1000; + let attempts = 0; + + while (attempts < maxAttempts) { + const getUrl = `${MapboxApiBasedTool.mapboxApiEndpoint}optimized-trips/v2/${jobId}?access_token=${accessToken}`; + const getResponse = await this.httpRequest(getUrl); + + if (!getResponse.ok) { + if (getResponse.status === 404) { + return { + content: [ + { + type: 'text', + text: `Optimization job ${jobId} not found` + } + ], + isError: true + }; + } + + const errorMessage = `Request failed with status ${getResponse.status}: ${getResponse.statusText}`; + + return { + content: [{ type: 'text', text: errorMessage }], + isError: true + }; + } + + // HTTP 200 means the optimization is complete + if (getResponse.status === 200) { + const result = (await getResponse.json()) as OptimizationOutput; + + // Validate the response against our output schema + try { + const validatedData = OptimizationOutputSchema.parse(result); + + return { + content: [ + { type: 'text', text: JSON.stringify(validatedData, null, 2) } + ], + structuredContent: validatedData, + isError: false + }; + } catch (validationError) { + // If validation fails, return the raw result anyway with a warning + this.log( + 'warning', + `Schema validation warning: ${validationError instanceof Error ? validationError.message : String(validationError)}` + ); + + return { + content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], + structuredContent: result, + isError: false + }; + } + } + + // HTTP 202 means still processing, wait and retry + await new Promise((resolve) => setTimeout(resolve, pollingInterval)); + attempts++; + } + + return { + content: [ + { + type: 'text', + text: `Optimization timed out after ${maxAttempts} attempts. Job ID: ${jobId}. You can check the status later using the job ID.` + } + ], + isError: true + }; + } +} diff --git a/src/tools/toolRegistry.ts b/src/tools/toolRegistry.ts index 2d6adcd..3bb828a 100644 --- a/src/tools/toolRegistry.ts +++ b/src/tools/toolRegistry.ts @@ -6,7 +6,9 @@ import { CategoryListTool } from './category-list-tool/CategoryListTool.js'; import { CategorySearchTool } from './category-search-tool/CategorySearchTool.js'; import { DirectionsTool } from './directions-tool/DirectionsTool.js'; import { IsochroneTool } from './isochrone-tool/IsochroneTool.js'; +import { MapMatchingTool } from './map-matching-tool/MapMatchingTool.js'; import { MatrixTool } from './matrix-tool/MatrixTool.js'; +import { OptimizationTool } from './optimization-tool/OptimizationTool.js'; import { ResourceReaderTool } from './resource-reader-tool/ResourceReaderTool.js'; import { ReverseGeocodeTool } from './reverse-geocode-tool/ReverseGeocodeTool.js'; import { StaticMapImageTool } from './static-map-image-tool/StaticMapImageTool.js'; @@ -23,7 +25,9 @@ export const ALL_TOOLS = [ new CategorySearchTool({ httpRequest }), new DirectionsTool({ httpRequest }), new IsochroneTool({ httpRequest }), + new MapMatchingTool({ httpRequest }), new MatrixTool({ httpRequest }), + new OptimizationTool({ httpRequest }), new ReverseGeocodeTool({ httpRequest }), new StaticMapImageTool({ httpRequest }), new SearchAndGeocodeTool({ httpRequest }) diff --git a/test/tools/map-matching-tool/MapMatchingTool.test.ts b/test/tools/map-matching-tool/MapMatchingTool.test.ts new file mode 100644 index 0000000..0c403aa --- /dev/null +++ b/test/tools/map-matching-tool/MapMatchingTool.test.ts @@ -0,0 +1,248 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +process.env.MAPBOX_ACCESS_TOKEN = + 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ0ZXN0In0.signature'; + +import { describe, it, expect, afterEach, vi } from 'vitest'; +import { + setupHttpRequest, + assertHeadersSent +} from '../../utils/httpPipelineUtils.js'; +import { MapMatchingTool } from '../../../src/tools/map-matching-tool/MapMatchingTool.js'; + +const sampleMapMatchingResponse = { + code: 'Ok', + matchings: [ + { + confidence: 0.95, + distance: 1234.5, + duration: 123.4, + geometry: { + type: 'LineString' as const, + coordinates: [ + [-122.4194, 37.7749], + [-122.4195, 37.775], + [-122.4197, 37.7751] + ] + }, + legs: [ + { + distance: 617.25, + duration: 61.7, + annotation: { + speed: [50, 45], + distance: [300, 317.25], + duration: [21.6, 40.1] + } + } + ] + } + ], + tracepoints: [ + { + name: 'Market Street', + location: [-122.4194, 37.7749], + waypoint_index: 0, + matchings_index: 0, + alternatives_count: 0 + }, + { + name: 'Market Street', + location: [-122.4195, 37.775], + matchings_index: 0, + alternatives_count: 1 + }, + { + name: 'Valencia Street', + location: [-122.4197, 37.7751], + matchings_index: 0, + alternatives_count: 0 + } + ] +}; + +describe('MapMatchingTool', () => { + afterEach(() => { + vi.restoreAllMocks(); + }); + + it('sends custom header', async () => { + const { httpRequest, mockHttpRequest } = setupHttpRequest(); + + await new MapMatchingTool({ httpRequest }).run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + profile: 'driving' + }); + + assertHeadersSent(mockHttpRequest); + }); + + it('returns structured content for valid coordinates', async () => { + const { httpRequest } = setupHttpRequest({ + json: async () => sampleMapMatchingResponse + }); + + const tool = new MapMatchingTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 }, + { longitude: -122.4197, latitude: 37.7751 } + ], + profile: 'driving' + }); + + expect(result.isError).toBe(false); + expect(result.structuredContent).toBeDefined(); + expect(result.structuredContent).toMatchObject({ + code: 'Ok', + matchings: expect.arrayContaining([ + expect.objectContaining({ + confidence: expect.any(Number), + distance: expect.any(Number), + duration: expect.any(Number) + }) + ]), + tracepoints: expect.any(Array) + }); + }); + + it('includes timestamps when provided', async () => { + const { httpRequest, mockHttpRequest } = setupHttpRequest({ + json: async () => sampleMapMatchingResponse + }); + + const tool = new MapMatchingTool({ httpRequest }); + await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + profile: 'driving', + timestamps: [1234567890, 1234567900] + }); + + const callUrl = mockHttpRequest.mock.calls[0][0] as string; + expect(callUrl).toContain('timestamps=1234567890%3B1234567900'); + }); + + it('includes radiuses when provided', async () => { + const { httpRequest, mockHttpRequest } = setupHttpRequest({ + json: async () => sampleMapMatchingResponse + }); + + const tool = new MapMatchingTool({ httpRequest }); + await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + profile: 'driving', + radiuses: [25, 25] + }); + + const callUrl = mockHttpRequest.mock.calls[0][0] as string; + expect(callUrl).toContain('radiuses=25%3B25'); + }); + + it('includes annotations when provided', async () => { + const { httpRequest, mockHttpRequest } = setupHttpRequest({ + json: async () => sampleMapMatchingResponse + }); + + const tool = new MapMatchingTool({ httpRequest }); + await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + profile: 'driving', + annotations: ['speed', 'congestion'] + }); + + const callUrl = mockHttpRequest.mock.calls[0][0] as string; + expect(callUrl).toContain('annotations=speed%2Ccongestion'); + }); + + it('returns error when timestamps length does not match coordinates', async () => { + const { httpRequest } = setupHttpRequest(); + + const tool = new MapMatchingTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + profile: 'driving', + timestamps: [1234567890] // Wrong length + }); + + expect(result.isError).toBe(true); + expect(result.content[0]).toMatchObject({ + type: 'text', + text: expect.stringContaining( + 'timestamps array must have the same length' + ) + }); + }); + + it('returns error when radiuses length does not match coordinates', async () => { + const { httpRequest } = setupHttpRequest(); + + const tool = new MapMatchingTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + profile: 'driving', + radiuses: [25, 25, 25] // Wrong length + }); + + expect(result.isError).toBe(true); + expect(result.content[0]).toMatchObject({ + type: 'text', + text: expect.stringContaining('radiuses array must have the same length') + }); + }); + + it('supports different routing profiles', async () => { + const { httpRequest, mockHttpRequest } = setupHttpRequest({ + json: async () => sampleMapMatchingResponse + }); + + const tool = new MapMatchingTool({ httpRequest }); + await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + profile: 'cycling' + }); + + const callUrl = mockHttpRequest.mock.calls[0][0] as string; + expect(callUrl).toContain('/matching/v5/mapbox/cycling/'); + }); + + it('uses geojson geometries by default', async () => { + const { httpRequest, mockHttpRequest } = setupHttpRequest({ + json: async () => sampleMapMatchingResponse + }); + + const tool = new MapMatchingTool({ httpRequest }); + await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + profile: 'driving' + }); + + const callUrl = mockHttpRequest.mock.calls[0][0] as string; + expect(callUrl).toContain('geometries=geojson'); + }); +}); diff --git a/test/tools/optimization-tool/OptimizationTool.test.ts b/test/tools/optimization-tool/OptimizationTool.test.ts new file mode 100644 index 0000000..3aa688b --- /dev/null +++ b/test/tools/optimization-tool/OptimizationTool.test.ts @@ -0,0 +1,478 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +process.env.MAPBOX_ACCESS_TOKEN = + 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ0ZXN0In0.signature'; + +import { describe, it, expect, afterEach, vi } from 'vitest'; +import { setupHttpRequest } from '../../utils/httpPipelineUtils.js'; +import { + HttpPipeline, + UserAgentPolicy +} from '../../../src/utils/httpPipeline.js'; +import { OptimizationTool } from '../../../src/tools/optimization-tool/OptimizationTool.js'; + +const sampleOptimizationJobResponse = { + id: 'test-job-123', + status: 'processing' +}; + +const sampleOptimizationResultResponse = { + routes: [ + { + vehicle: 'vehicle-1', + stops: [ + { + type: 'start', + location: 'location-0', + eta: '2024-01-01T10:00:00Z', + odometer: 0, + wait: 0, + duration: 0 + }, + { + type: 'service', + location: 'location-1', + eta: '2024-01-01T10:05:00Z', + odometer: 1500, + wait: 0, + duration: 300, + services: ['service-1'] + }, + { + type: 'service', + location: 'location-2', + eta: '2024-01-01T10:12:00Z', + odometer: 3200, + wait: 0, + duration: 300, + services: ['service-2'] + }, + { + type: 'end', + location: 'location-0', + eta: '2024-01-01T10:20:00Z', + odometer: 5000, + wait: 0, + duration: 0 + } + ] + } + ], + dropped: { + services: [], + shipments: [] + } +}; + +// Helper function to create mock httpRequest with polling behavior +function createMockWithPolling( + postResponse: unknown, + getResponse: unknown | ((callNum: number) => unknown) +) { + const mockHttpRequest = vi.fn(); + let callCount = 0; + + mockHttpRequest.mockImplementation(() => { + callCount++; + // First call: POST to create job + if (callCount === 1) { + return Promise.resolve({ + ok: true, + status: 200, + json: async () => postResponse + }); + } + // Subsequent calls: GET polling + const response = + typeof getResponse === 'function' ? getResponse(callCount) : getResponse; + return Promise.resolve(response); + }); + + const pipeline = new HttpPipeline(mockHttpRequest); + const userAgent = 'TestServer/1.0.0 (default, no-tag, abcdef)'; + pipeline.usePolicy(new UserAgentPolicy(userAgent)); + + return { + httpRequest: pipeline.execute.bind(pipeline), + mockHttpRequest + }; +} + +describe('OptimizationTool', () => { + afterEach(() => { + vi.restoreAllMocks(); + }); + + it('sends custom header', async () => { + const { httpRequest, mockHttpRequest } = createMockWithPolling( + sampleOptimizationJobResponse, + { + ok: true, + status: 200, + json: async () => sampleOptimizationResultResponse + } + ); + + await new OptimizationTool({ httpRequest }).run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 }, + { longitude: -122.4197, latitude: 37.7751 } + ] + }); + + // OptimizationTool makes 2 calls (POST + GET polling), verify headers on both + expect(mockHttpRequest).toHaveBeenCalledTimes(2); + const firstCallArgs = mockHttpRequest.mock.calls[0]; + expect(firstCallArgs[1]?.headers).toMatchObject({ + 'User-Agent': expect.any(String) + }); + }); + + it('works in simplified mode with default vehicle', async () => { + const { httpRequest, mockHttpRequest } = createMockWithPolling( + sampleOptimizationJobResponse, + { + ok: true, + status: 200, + json: async () => sampleOptimizationResultResponse + } + ); + + const tool = new OptimizationTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 }, + { longitude: -122.4197, latitude: 37.7751 } + ], + profile: 'mapbox/driving' + }); + + expect(result.isError).toBe(false); + expect(result.structuredContent).toBeDefined(); + + // Verify POST request body includes auto-generated locations and vehicle + const firstCall = mockHttpRequest.mock.calls[0]; + const postBody = JSON.parse((firstCall[1] as { body: string }).body); + + expect(postBody.locations).toHaveLength(3); + expect(postBody.locations[0].name).toBe('location-0'); + expect(postBody.vehicles).toHaveLength(1); + expect(postBody.vehicles[0].name).toBe('vehicle-1'); + expect(postBody.vehicles[0].start_location).toBe('location-0'); + expect(postBody.vehicles[0].end_location).toBe('location-0'); + + // In simplified mode, services are created for all locations except first + expect(postBody.services).toHaveLength(2); + expect(postBody.services[0].name).toBe('service-1'); + expect(postBody.services[0].location).toBe('location-1'); + }); + + it('works in advanced mode with custom vehicles and services', async () => { + const { httpRequest, mockHttpRequest } = createMockWithPolling( + sampleOptimizationJobResponse, + { + ok: true, + status: 200, + json: async () => sampleOptimizationResultResponse + } + ); + + const tool = new OptimizationTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + vehicles: [ + { + name: 'custom-vehicle', + routing_profile: 'mapbox/driving', + start_location: 'location-0', + end_location: 'location-0' + } + ], + services: [ + { + name: 'custom-service', + location: 'location-1', + duration: 300 + } + ] + }); + + expect(result.isError).toBe(false); + + const firstCall = mockHttpRequest.mock.calls[0]; + const postBody = JSON.parse((firstCall[1] as { body: string }).body); + + expect(postBody.vehicles[0].name).toBe('custom-vehicle'); + expect(postBody.services[0].name).toBe('custom-service'); + }); + + it('works with shipments instead of services', async () => { + const shipmentResponse = { + ...sampleOptimizationResultResponse, + routes: [ + { + vehicle: 'vehicle-1', + stops: [ + { + type: 'start', + location: 'location-0', + eta: '2024-01-01T10:00:00Z', + odometer: 0, + wait: 0, + duration: 0 + }, + { + type: 'pickup', + location: 'location-1', + eta: '2024-01-01T10:05:00Z', + odometer: 1500, + wait: 0, + duration: 300, + pickups: ['shipment-1'] + }, + { + type: 'dropoff', + location: 'location-2', + eta: '2024-01-01T10:12:00Z', + odometer: 3200, + wait: 0, + duration: 300, + dropoffs: ['shipment-1'] + }, + { + type: 'end', + location: 'location-0', + eta: '2024-01-01T10:20:00Z', + odometer: 5000, + wait: 0, + duration: 0 + } + ] + } + ] + }; + + const { httpRequest, mockHttpRequest } = createMockWithPolling( + sampleOptimizationJobResponse, + { + ok: true, + status: 200, + json: async () => shipmentResponse + } + ); + + const tool = new OptimizationTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 }, + { longitude: -122.4197, latitude: 37.7751 } + ], + vehicles: [ + { + name: 'delivery-vehicle', + routing_profile: 'mapbox/driving', + start_location: 'location-0', + end_location: 'location-0' + } + ], + shipments: [ + { + name: 'shipment-1', + from: 'location-1', + to: 'location-2', + pickup_duration: 300, + dropoff_duration: 300 + } + ] + }); + + expect(result.isError).toBe(false); + + const firstCall = mockHttpRequest.mock.calls[0]; + const postBody = JSON.parse((firstCall[1] as { body: string }).body); + + expect(postBody.shipments).toHaveLength(1); + expect(postBody.shipments[0].name).toBe('shipment-1'); + expect(postBody.shipments[0].from).toBe('location-1'); + expect(postBody.shipments[0].to).toBe('location-2'); + }); + + it('returns error when vehicles provided without services or shipments', async () => { + const { httpRequest } = setupHttpRequest(); + + const tool = new OptimizationTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + vehicles: [ + { + name: 'vehicle-1', + routing_profile: 'mapbox/driving', + start_location: 'location-0', + end_location: 'location-0' + } + ] + // Missing services or shipments + }); + + expect(result.isError).toBe(true); + expect(result.content[0]).toMatchObject({ + type: 'text', + text: expect.stringContaining( + 'at least one service or shipment is required' + ) + }); + }); + + it('handles polling timeout', async () => { + const { httpRequest } = createMockWithPolling( + sampleOptimizationJobResponse, + { + ok: true, + status: 202, + json: async () => ({ status: 'processing' }) + } + ); + + const tool = new OptimizationTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + max_polling_attempts: 2, + polling_interval_ms: 10 + }); + + expect(result.isError).toBe(true); + expect(result.content[0]).toMatchObject({ + type: 'text', + text: expect.stringContaining('timed out after 2 attempts') + }); + }); + + it('handles API error on POST', async () => { + const { httpRequest } = setupHttpRequest({ + ok: false, + status: 400, + statusText: 'Bad Request', + text: async () => + JSON.stringify({ message: 'Invalid coordinates provided' }) + }); + + const tool = new OptimizationTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ] + }); + + expect(result.isError).toBe(true); + expect(result.content[0]).toMatchObject({ + type: 'text', + text: expect.stringContaining('Invalid coordinates provided') + }); + }); + + it('handles 404 on polling GET', async () => { + const { httpRequest } = createMockWithPolling( + sampleOptimizationJobResponse, + { + ok: false, + status: 404, + statusText: 'Not Found' + } + ); + + const tool = new OptimizationTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ] + }); + + expect(result.isError).toBe(true); + expect(result.content[0]).toMatchObject({ + type: 'text', + text: expect.stringContaining('not found') + }); + }); + + it('uses correct routing profile', async () => { + let callCount = 0; + const { httpRequest, mockHttpRequest } = setupHttpRequest(() => { + callCount++; + if (callCount === 1) { + return { + ok: true, + status: 200, + json: async () => sampleOptimizationJobResponse + }; + } + return { + ok: true, + status: 200, + json: async () => sampleOptimizationResultResponse + }; + }); + + const tool = new OptimizationTool({ httpRequest }); + await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ], + profile: 'mapbox/cycling' + }); + + const firstCall = mockHttpRequest.mock.calls[0]; + const postBody = JSON.parse((firstCall[1] as { body: string }).body); + + expect(postBody.vehicles[0].routing_profile).toBe('mapbox/cycling'); + }); + + it('includes structured content in successful response', async () => { + const { httpRequest } = createMockWithPolling( + sampleOptimizationJobResponse, + { + ok: true, + status: 200, + json: async () => sampleOptimizationResultResponse + } + ); + + const tool = new OptimizationTool({ httpRequest }); + const result = await tool.run({ + coordinates: [ + { longitude: -122.4194, latitude: 37.7749 }, + { longitude: -122.4195, latitude: 37.775 } + ] + }); + + expect(result.isError).toBe(false); + expect(result.structuredContent).toBeDefined(); + expect(result.structuredContent).toMatchObject({ + routes: expect.arrayContaining([ + expect.objectContaining({ + vehicle: expect.any(String), + stops: expect.any(Array) + }) + ]), + dropped: expect.objectContaining({ + services: expect.any(Array), + shipments: expect.any(Array) + }) + }); + }); +}); From 5aa11c46bd47e0e32605d18053e5f49658401901 Mon Sep 17 00:00:00 2001 From: Matthew Podwysocki Date: Mon, 5 Jan 2026 23:41:35 -0500 Subject: [PATCH 2/8] Convert OptimizationTool to MCP Tasks for async operation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This commit converts the OptimizationTool from a synchronous blocking tool to an async task-based tool using the experimental MCP Tasks API. **Problem:** The Optimization API v2 is long-running (up to 10 seconds with polling), blocking the agent from doing other work while waiting for results. **Solution:** Implemented task-based execution using MCP SDK 1.25.1's experimental tasks API: - **src/tools/optimization-tool/OptimizationTask.ts** (NEW): Task-based implementation with three handlers: - createTask: Submits optimization job to Mapbox API, returns immediately without blocking - getTask: Returns current task status (pending, working, completed, failed) - getTaskResult: Returns final optimization results when complete - Background polling runs asynchronously with proper error handling - **src/index.ts**: Added task support to server - Created InMemoryTaskStore and InMemoryTaskMessageQueue - Updated server capabilities to include tasks: { requests: { tools: { call: {} } } } - Registered OptimizationTask instead of synchronous OptimizationTool - Fixed "Type instantiation is excessively deep" error in GetPromptRequestSchema handler with type assertions (workaround for MCP SDK 1.25.1 issue #985) - **src/tools/BaseTool.ts**: Fixed TypeScript compilation error - Added type assertions to break complex type inference chains - Workaround for "Type instantiation is excessively deep" errors with MCP SDK 1.25.1 generic types **Benefits:** - Non-blocking execution - returns task ID immediately - Agent can do other work while optimization runs in background - Progress updates via task status messages - Proper error handling and timeout management - All existing tests pass (422 tests) - Zero TypeScript compilation errors **Testing:** - Server starts successfully with task support - All 422 existing tests pass - Build completes without errors 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 --- src/index.ts | 69 ++- src/tools/BaseTool.ts | 13 +- .../optimization-tool/OptimizationTask.ts | 421 ++++++++++++++++++ 3 files changed, 480 insertions(+), 23 deletions(-) create mode 100644 src/tools/optimization-tool/OptimizationTask.ts diff --git a/src/index.ts b/src/index.ts index 2489a23..6e6fbd7 100644 --- a/src/index.ts +++ b/src/index.ts @@ -15,11 +15,17 @@ import { ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js'; +import { + InMemoryTaskStore, + InMemoryTaskMessageQueue +} from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js'; import { parseToolConfigFromArgs, filterTools } from './config/toolConfig.js'; import { getAllTools } from './tools/toolRegistry.js'; import { getAllResources } from './resources/resourceRegistry.js'; import { getAllPrompts, getPromptByName } from './prompts/promptRegistry.js'; import { getVersionInfo } from './utils/versionUtils.js'; +import { registerOptimizationTask } from './tools/optimization-tool/OptimizationTask.js'; +import { httpRequest } from './utils/httpPipeline.js'; import { initializeTracing, shutdownTracing, @@ -62,6 +68,9 @@ const enabledTools = filterTools(allTools, config); // Get all resources const allResources = getAllResources(); +// Create task store for async operations +const taskStore = new InMemoryTaskStore(); + // Create an MCP server const server = new McpServer( { @@ -72,16 +81,26 @@ const server = new McpServer( capabilities: { tools: {}, resources: {}, - prompts: {} - } + prompts: {}, + tasks: { requests: { tools: { call: {} } } } + }, + taskStore, + taskMessageQueue: new InMemoryTaskMessageQueue() } ); // Register enabled tools to the server enabledTools.forEach((tool) => { + // Skip OptimizationTool as it's registered as a task instead + if (tool.name === 'optimization_tool') { + return; + } tool.installTo(server); }); +// Register task-based tools +registerOptimizationTask(server, httpRequest); + // Register all resources to the server allResources.forEach((resource) => { resource.installTo(server); @@ -95,28 +114,36 @@ server.server.setRequestHandler(ListPromptsRequestSchema, async () => { }; }); -server.server.setRequestHandler(GetPromptRequestSchema, async (request) => { - const { name, arguments: args } = request.params; - - const prompt = getPromptByName(name); - if (!prompt) { - throw new Error(`Prompt not found: ${name}`); - } +// Type assertion to avoid "Type instantiation is excessively deep" error +// This is a known issue in MCP SDK 1.25.1: https://github.com/modelcontextprotocol/typescript-sdk/issues/985 +// TODO: Remove this workaround when SDK fixes their type definitions +// eslint-disable-next-line @typescript-eslint/no-explicit-any +(server.server as any).setRequestHandler( + GetPromptRequestSchema, + // eslint-disable-next-line @typescript-eslint/no-explicit-any + async (request: any) => { + const { name, arguments: args } = request.params; + + const prompt = getPromptByName(name); + if (!prompt) { + throw new Error(`Prompt not found: ${name}`); + } - // Convert args to object for easier access - const argsObj: Record = {}; - if (args && typeof args === 'object') { - Object.assign(argsObj, args); - } + // Convert args to object for easier access + const argsObj: Record = {}; + if (args && typeof args === 'object') { + Object.assign(argsObj, args); + } - // Get the prompt messages with filled-in arguments - const messages = prompt.getMessages(argsObj); + // Get the prompt messages with filled-in arguments + const messages = prompt.getMessages(argsObj); - return { - description: prompt.description, - messages - }; -}); + return { + description: prompt.description, + messages + }; + } +); async function main() { // Initialize OpenTelemetry tracing if not in test mode diff --git a/src/tools/BaseTool.ts b/src/tools/BaseTool.ts index a6fb1d9..08db781 100644 --- a/src/tools/BaseTool.ts +++ b/src/tools/BaseTool.ts @@ -62,8 +62,17 @@ export abstract class BaseTool< (this.outputSchema as unknown as z.ZodObject).shape; } - return server.registerTool(this.name, config, (args, extra) => - this.run(args, extra) + // Type assertion to avoid "Type instantiation is excessively deep" error + // This is a known issue in MCP SDK 1.25.1: https://github.com/modelcontextprotocol/typescript-sdk/issues/985 + // TODO: Remove this workaround when SDK fixes their type definitions + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const serverAny = server as any; + + return serverAny.registerTool( + this.name, + config, + // eslint-disable-next-line @typescript-eslint/no-explicit-any + (args: any, extra: any) => this.run(args, extra) ); } diff --git a/src/tools/optimization-tool/OptimizationTask.ts b/src/tools/optimization-tool/OptimizationTask.ts new file mode 100644 index 0000000..ed9de9e --- /dev/null +++ b/src/tools/optimization-tool/OptimizationTask.ts @@ -0,0 +1,421 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import type { z } from 'zod'; +import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'; +import type { HttpRequest } from '../../utils/types.js'; +import type { + TaskStore, + CreateTaskRequestHandlerExtra, + TaskRequestHandlerExtra +} from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js'; +import { OptimizationInputSchema } from './OptimizationTool.input.schema.js'; +import { + OptimizationOutputSchema, + type OptimizationOutput +} from './OptimizationTool.output.schema.js'; + +// API documentation: https://docs.mapbox.com/api/navigation/optimization/ + +/** + * Helper function to validate JWT format + */ +function isValidJwtFormat(token: string): boolean { + const parts = token.split('.'); + if (parts.length !== 3) return false; + return parts.every((part) => part.length > 0); +} + +/** + * Helper function to get Mapbox API endpoint + */ +function getMapboxApiEndpoint(): string { + return process.env.MAPBOX_API_ENDPOINT || 'https://api.mapbox.com/'; +} + +/** + * Core function to submit optimization job to Mapbox API + */ +async function submitOptimizationJob( + input: z.infer, + accessToken: string, + httpRequest: HttpRequest +): Promise<{ jobId: string; status: string }> { + // Validate: If vehicles are provided, at least one service or shipment is required + if (input.vehicles && input.vehicles.length > 0) { + const hasServices = input.services && input.services.length > 0; + const hasShipments = input.shipments && input.shipments.length > 0; + + if (!hasServices && !hasShipments) { + throw new Error( + 'When vehicles are provided, at least one service or shipment is required' + ); + } + } + + // Convert simplified input to Optimization API v2 format + // Create locations array with auto-generated names + const locations = input.coordinates.map((coord, index) => ({ + name: `location-${index}`, + coordinates: [coord.longitude, coord.latitude] as [number, number] + })); + + // If vehicles are not provided, create a default vehicle + let vehicles: Array; + let services: Array; + let shipments: Array | undefined; + + if (!input.vehicles || input.vehicles.length === 0) { + // Simplified mode: auto-generate vehicle and services from coordinates + vehicles = [ + { + name: 'vehicle-1', + routing_profile: input.profile, + start_location: 'location-0', // Start at first location + end_location: 'location-0' // Return to first location + } + ]; + + // Create services for all locations except the first (which is start/end) + services = input.coordinates.slice(1).map((_, index) => ({ + name: `service-${index + 1}`, + location: `location-${index + 1}`, + duration: 0 // No service time by default + })); + } else { + // Advanced mode: use provided vehicles, services, and shipments + vehicles = input.vehicles; + services = input.services || []; + shipments = input.shipments; + } + + // Build request body + const requestBody: { + version: number; + locations: Array<{ name: string; coordinates: [number, number] }>; + vehicles: Array; + services: Array; + shipments?: Array; + } = { + version: 1, + locations, + vehicles, + services + }; + + if (shipments && shipments.length > 0) { + requestBody.shipments = shipments; + } + + // Step 1: POST to create optimization job + const postUrl = `${getMapboxApiEndpoint()}optimized-trips/v2?access_token=${accessToken}`; + + const postResponse = await httpRequest(postUrl, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify(requestBody) + }); + + if (!postResponse.ok) { + const errorText = await postResponse.text(); + let errorMessage = `Request failed with status ${postResponse.status}: ${postResponse.statusText}`; + + try { + const errorJson = JSON.parse(errorText); + if (errorJson.message) { + errorMessage = `${errorMessage} - ${errorJson.message}`; + } + } catch { + // If parsing fails, use the raw text + if (errorText) { + errorMessage = `${errorMessage} - ${errorText}`; + } + } + + throw new Error(errorMessage); + } + + const postData = (await postResponse.json()) as { + id: string; + status: string; + }; + + return { + jobId: postData.id, + status: postData.status + }; +} + +/** + * Core function to poll optimization job status + */ +async function pollOptimizationJob( + jobId: string, + accessToken: string, + httpRequest: HttpRequest +): Promise<{ status: number; data?: OptimizationOutput; error?: string }> { + const getUrl = `${getMapboxApiEndpoint()}optimized-trips/v2/${jobId}?access_token=${accessToken}`; + const getResponse = await httpRequest(getUrl); + + if (!getResponse.ok) { + if (getResponse.status === 404) { + return { + status: 404, + error: `Optimization job ${jobId} not found` + }; + } + + return { + status: getResponse.status, + error: `Request failed with status ${getResponse.status}: ${getResponse.statusText}` + }; + } + + // HTTP 200 means the optimization is complete + if (getResponse.status === 200) { + const result = (await getResponse.json()) as OptimizationOutput; + return { + status: 200, + data: result + }; + } + + // HTTP 202 means still processing + return { + status: 202 + }; +} + +/** + * Background polling function that runs until job completes + */ +async function backgroundPollOptimizationJob( + jobId: string, + accessToken: string, + httpRequest: HttpRequest, + taskStore: TaskStore, + taskId: string, + maxAttempts: number, + pollingInterval: number +): Promise { + let attempts = 0; + + while (attempts < maxAttempts) { + try { + const pollResult = await pollOptimizationJob( + jobId, + accessToken, + httpRequest + ); + + if (pollResult.status === 200 && pollResult.data) { + // Job completed successfully + try { + const validatedData = OptimizationOutputSchema.parse(pollResult.data); + + await taskStore.storeTaskResult(taskId, 'completed', { + content: [ + { type: 'text', text: JSON.stringify(validatedData, null, 2) } + ], + structuredContent: validatedData + }); + } catch { + // If validation fails, return raw result anyway + await taskStore.storeTaskResult(taskId, 'completed', { + content: [ + { type: 'text', text: JSON.stringify(pollResult.data, null, 2) } + ], + structuredContent: pollResult.data + }); + } + return; + } else if (pollResult.error) { + // Job failed or not found + await taskStore.storeTaskResult(taskId, 'failed', { + content: [{ type: 'text', text: pollResult.error }], + isError: true + }); + return; + } + + // Still processing (status 202), update task status + await taskStore.updateTaskStatus( + taskId, + 'working', + `Processing optimization job (attempt ${attempts + 1}/${maxAttempts})` + ); + + // Wait before next poll + await new Promise((resolve) => setTimeout(resolve, pollingInterval)); + attempts++; + } catch (error) { + // Error during polling + await taskStore.storeTaskResult(taskId, 'failed', { + content: [ + { + type: 'text', + text: `Error polling optimization job: ${error instanceof Error ? error.message : String(error)}` + } + ], + isError: true + }); + return; + } + } + + // Timed out + await taskStore.storeTaskResult(taskId, 'failed', { + content: [ + { + type: 'text', + text: `Optimization timed out after ${maxAttempts} attempts. Job ID: ${jobId}. You can check the status later using the job ID.` + } + ], + isError: true + }); +} + +/** + * Register the Optimization tool as a task-based tool + */ +export function registerOptimizationTask( + server: McpServer, + httpRequest: HttpRequest +): void { + server.experimental.tasks.registerToolTask( + 'optimization_tool', + { + title: 'Optimization Tool', + description: + 'Solves vehicle routing problems using the Mapbox Optimization API v2. ' + + 'This is a long-running async task that submits an optimization job and polls for results. ' + + 'Supports up to 1000 coordinates in {longitude, latitude} format. ' + + 'Returns optimized routes with stops, ETAs, and dropped items. ' + + '\n\n' + + 'USAGE MODES:\n' + + '1. SIMPLIFIED MODE (recommended for basic routing): Provide only "coordinates" and optionally "profile". ' + + 'The tool will automatically create a default vehicle that visits all locations in optimized order, ' + + 'starting and ending at the first coordinate.\n' + + '2. ADVANCED MODE (for complex scenarios): If you specify "vehicles", you MUST also provide either ' + + '"services" (single stops like deliveries or pickups) or "shipments" (paired pickup/dropoff tasks). ' + + 'Each service/shipment defines a stop that vehicles must visit.\n' + + '\n' + + 'KEY CONCEPTS:\n' + + '- "services": Individual stops at locations (e.g., deliver package to address A, pick up at coffee shop B)\n' + + '- "shipments": Paired pickup/delivery tasks (e.g., pick up from warehouse, deliver to customer)\n' + + '- "vehicles": Routing agents with optional constraints like time windows, capacities, and capabilities\n' + + '\n' + + 'LOCATION NAMING (CRITICAL):\n' + + 'The tool auto-generates STRING location names from your coordinates array as "location-0", "location-1", "location-2", etc. ' + + 'When creating services, shipments, or vehicles, you MUST reference these auto-generated STRINGS (NOT integers, NOT array indices):\n' + + '- coordinates[0] → use STRING "location-0" (NOT integer 0)\n' + + '\n' + + 'EXAMPLES:\n' + + '✓ CORRECT: service.location = "location-2" (string)\n' + + '✗ WRONG: service.location = 2 (integer)\n' + + '\n' + + 'IMPORTANT: This is an async task. The task will start immediately but results will be available later via task polling.', + inputSchema: OptimizationInputSchema, + outputSchema: OptimizationOutputSchema, + annotations: { + title: 'Optimization Tool', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: false, + openWorldHint: true + } + }, + { + async createTask(args: unknown, extra: CreateTaskRequestHandlerExtra) { + // Validate input + const input = OptimizationInputSchema.parse(args); + + // Get and validate access token (from environment only for now) + const accessToken = + process.env.MAPBOX_ACCESS_TOKEN || + ( + extra as CreateTaskRequestHandlerExtra & { + authInfo?: { token?: string }; + } + ).authInfo?.token; + if (!accessToken) { + throw new Error( + 'No access token available. Please provide via Bearer auth or MAPBOX_ACCESS_TOKEN env var' + ); + } + if (!isValidJwtFormat(accessToken)) { + throw new Error('Access token is not in valid JWT format'); + } + + // Create the task + const task = await extra.taskStore.createTask({ + ttl: 300000 // 5 minutes TTL + }); + + // Submit optimization job to Mapbox API + try { + const { jobId } = await submitOptimizationJob( + input, + accessToken, + httpRequest + ); + + // Start background polling (fire and forget) + const maxAttempts = input.max_polling_attempts ?? 10; + const pollingInterval = input.polling_interval_ms ?? 1000; + + // Don't await this - let it run in the background + void backgroundPollOptimizationJob( + jobId, + accessToken, + httpRequest, + extra.taskStore, + task.taskId, + maxAttempts, + pollingInterval + ); + + // Update task status to show it's working + await extra.taskStore.updateTaskStatus( + task.taskId, + 'working', + `Optimization job submitted: ${jobId}` + ); + + // Return CreateTaskResult with the created task + return { + task + }; + } catch (error) { + // Failed to submit job, mark task as failed + await extra.taskStore.storeTaskResult(task.taskId, 'failed', { + content: [ + { + type: 'text', + text: `Failed to submit optimization job: ${error instanceof Error ? error.message : String(error)}` + } + ], + isError: true + }); + + throw error; + } + }, + + async getTask(_args: unknown, extra: TaskRequestHandlerExtra) { + const task = await extra.taskStore.getTask(extra.taskId); + if (!task) { + throw new Error(`Task ${extra.taskId} not found`); + } + return task; + }, + + async getTaskResult(_args: unknown, extra: TaskRequestHandlerExtra) { + const result = await extra.taskStore.getTaskResult(extra.taskId); + // taskStore.getTaskResult returns a Result type, but we know we stored a CallToolResult + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return result as any; + } + } + ); +} From 85291bfc46343639217db042cf4de09ef5bdd649 Mon Sep 17 00:00:00 2001 From: Matthew Podwysocki Date: Wed, 7 Jan 2026 10:38:59 -0500 Subject: [PATCH 3/8] Update SDK to 1.25.1 and apply icons patch MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Upgrade @modelcontextprotocol/sdk from 1.21.1 to 1.25.1 - Remove old SDK 1.21.1 patch - Apply SDK 1.25.1 patch with icons support and output validation fixes - Update version to 0.8.1 to match main branch - All 422 tests passing This brings the task-based optimization branch up to date with the latest SDK and includes the necessary patches for proper operation. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 --- manifest.json | 2 +- package-lock.json | 5142 ++++++++--------- package.json | 4 +- .../@modelcontextprotocol+sdk+1.21.1.patch | 54 - .../@modelcontextprotocol+sdk+1.25.1.patch | 122 + 5 files changed, 2547 insertions(+), 2777 deletions(-) delete mode 100644 patches/@modelcontextprotocol+sdk+1.21.1.patch create mode 100644 patches/@modelcontextprotocol+sdk+1.25.1.patch diff --git a/manifest.json b/manifest.json index 825eb29..7a385b3 100644 --- a/manifest.json +++ b/manifest.json @@ -2,7 +2,7 @@ "dxt_version": "0.1", "display_name": "Mapbox MCP Server", "name": "@mapbox/mcp-server", - "version": "0.8.0", + "version": "0.8.1", "description": "Mapbox MCP server.", "author": { "name": "Mapbox, Inc." diff --git a/package-lock.json b/package-lock.json index a2d0518..bece05b 100644 --- a/package-lock.json +++ b/package-lock.json @@ -7,10 +7,11 @@ "": { "name": "@mapbox/mcp-server", "version": "0.8.0", + "hasInstallScript": true, "license": "MIT", "dependencies": { "@mcp-ui/server": "^5.13.1", - "@modelcontextprotocol/sdk": "^1.21.1", + "@modelcontextprotocol/sdk": "^1.25.1", "@opentelemetry/api": "^1.9.0", "@opentelemetry/auto-instrumentations-node": "^0.56.0", "@opentelemetry/exporter-trace-otlp-http": "^0.56.0", @@ -51,24 +52,12 @@ "node": ">=22" } }, - "node_modules/@ampproject/remapping": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz", - "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==", - "dev": true, - "dependencies": { - "@jridgewell/gen-mapping": "^0.3.5", - "@jridgewell/trace-mapping": "^0.3.24" - }, - "engines": { - "node": ">=6.0.0" - } - }, "node_modules/@babel/code-frame": { "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz", "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-validator-identifier": "^7.27.1", "js-tokens": "^4.0.0", @@ -79,30 +68,32 @@ } }, "node_modules/@babel/compat-data": { - "version": "7.27.3", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.27.3.tgz", - "integrity": "sha512-V42wFfx1ymFte+ecf6iXghnnP8kWTO+ZLXIyZq+1LAXHHvTZdVxicn4yiVYdYMGaCO3tmqub11AorKkv+iodqw==", + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.5.tgz", + "integrity": "sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/core": { - "version": "7.27.3", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.27.3.tgz", - "integrity": "sha512-hyrN8ivxfvJ4i0fIJuV4EOlV0WDMz5Ui4StRTgVaAvWeiRCilXgwVvxJKtFQ3TKtHgJscB2YiXKGNJuVwhQMtA==", + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz", + "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==", "dev": true, + "license": "MIT", "dependencies": { - "@ampproject/remapping": "^2.2.0", "@babel/code-frame": "^7.27.1", - "@babel/generator": "^7.27.3", + "@babel/generator": "^7.28.5", "@babel/helper-compilation-targets": "^7.27.2", - "@babel/helper-module-transforms": "^7.27.3", - "@babel/helpers": "^7.27.3", - "@babel/parser": "^7.27.3", + "@babel/helper-module-transforms": "^7.28.3", + "@babel/helpers": "^7.28.4", + "@babel/parser": "^7.28.5", "@babel/template": "^7.27.2", - "@babel/traverse": "^7.27.3", - "@babel/types": "^7.27.3", + "@babel/traverse": "^7.28.5", + "@babel/types": "^7.28.5", + "@jridgewell/remapping": "^2.3.5", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", @@ -122,20 +113,22 @@ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "dev": true, + "license": "ISC", "bin": { "semver": "bin/semver.js" } }, "node_modules/@babel/generator": { - "version": "7.27.3", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.27.3.tgz", - "integrity": "sha512-xnlJYj5zepml8NXtjkG0WquFUv8RskFqyFcVgTBp5k+NaA/8uw/K+OSVf8AMGw5e9HKP2ETd5xpK5MLZQD6b4Q==", + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.5.tgz", + "integrity": "sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ==", "dev": true, + "license": "MIT", "dependencies": { - "@babel/parser": "^7.27.3", - "@babel/types": "^7.27.3", - "@jridgewell/gen-mapping": "^0.3.5", - "@jridgewell/trace-mapping": "^0.3.25", + "@babel/parser": "^7.28.5", + "@babel/types": "^7.28.5", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", "jsesc": "^3.0.2" }, "engines": { @@ -147,6 +140,7 @@ "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz", "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==", "dev": true, + "license": "MIT", "dependencies": { "@babel/compat-data": "^7.27.2", "@babel/helper-validator-option": "^7.27.1", @@ -163,15 +157,27 @@ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "dev": true, + "license": "ISC", "bin": { "semver": "bin/semver.js" } }, + "node_modules/@babel/helper-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/@babel/helper-module-imports": { "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz", "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==", "dev": true, + "license": "MIT", "dependencies": { "@babel/traverse": "^7.27.1", "@babel/types": "^7.27.1" @@ -181,14 +187,15 @@ } }, "node_modules/@babel/helper-module-transforms": { - "version": "7.27.3", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.27.3.tgz", - "integrity": "sha512-dSOvYwvyLsWBeIRyOeHXp5vPj5l1I011r52FM1+r1jCERv+aFXYk4whgQccYEGYxK2H3ZAIA8nuPkQ0HaUo3qg==", + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz", + "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-module-imports": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1", - "@babel/traverse": "^7.27.3" + "@babel/traverse": "^7.28.3" }, "engines": { "node": ">=6.9.0" @@ -202,15 +209,17 @@ "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-validator-identifier": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz", - "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==", + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.9.0" } @@ -220,30 +229,33 @@ "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helpers": { - "version": "7.27.3", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.27.3.tgz", - "integrity": "sha512-h/eKy9agOya1IGuLaZ9tEUgz+uIRXcbtOhRtUyyMf8JFmn1iT13vnl/IGVWSkdOCG/pC57U4S1jnAabAavTMwg==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz", + "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==", "dev": true, + "license": "MIT", "dependencies": { "@babel/template": "^7.27.2", - "@babel/types": "^7.27.3" + "@babel/types": "^7.28.4" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/parser": { - "version": "7.27.3", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.3.tgz", - "integrity": "sha512-xyYxRj6+tLNDTWi0KCBcZ9V7yg3/lwL9DWh9Uwh/RIVlIfFidggcgxKX3GCXwCiswwcGRawBKbEg2LG/Y8eJhw==", + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz", + "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==", "dev": true, + "license": "MIT", "dependencies": { - "@babel/types": "^7.27.3" + "@babel/types": "^7.28.5" }, "bin": { "parser": "bin/babel-parser.js" @@ -257,6 +269,7 @@ "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz", "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==", "dev": true, + "license": "MIT", "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/parser": "^7.27.2", @@ -267,81 +280,74 @@ } }, "node_modules/@babel/traverse": { - "version": "7.27.3", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.27.3.tgz", - "integrity": "sha512-lId/IfN/Ye1CIu8xG7oKBHXd2iNb2aW1ilPszzGcJug6M8RCKfVNcYhpI5+bMvFYjK7lXIM0R+a+6r8xhHp2FQ==", + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.5.tgz", + "integrity": "sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==", "dev": true, + "license": "MIT", "dependencies": { "@babel/code-frame": "^7.27.1", - "@babel/generator": "^7.27.3", - "@babel/parser": "^7.27.3", + "@babel/generator": "^7.28.5", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.28.5", "@babel/template": "^7.27.2", - "@babel/types": "^7.27.3", - "debug": "^4.3.1", - "globals": "^11.1.0" + "@babel/types": "^7.28.5", + "debug": "^4.3.1" }, "engines": { "node": ">=6.9.0" } }, - "node_modules/@babel/traverse/node_modules/globals": { - "version": "11.12.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", - "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", - "dev": true, - "engines": { - "node": ">=4" - } - }, "node_modules/@babel/types": { - "version": "7.27.3", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.3.tgz", - "integrity": "sha512-Y1GkI4ktrtvmawoSq+4FCVHNryea6uR+qUQy0AGxLSsjCX0nVmkYQMBLHDkXZuo5hGx7eYdnIaslsdBFm7zbUw==", + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz", + "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-string-parser": "^7.27.1", - "@babel/helper-validator-identifier": "^7.27.1" + "@babel/helper-validator-identifier": "^7.28.5" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@cspell/cspell-bundled-dicts": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/@cspell/cspell-bundled-dicts/-/cspell-bundled-dicts-9.2.1.tgz", - "integrity": "sha512-85gHoZh3rgZ/EqrHIr1/I4OLO53fWNp6JZCqCdgaT7e3sMDaOOG6HoSxCvOnVspXNIf/1ZbfTCDMx9x79Xq0AQ==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/@cspell/cspell-bundled-dicts/-/cspell-bundled-dicts-9.4.0.tgz", + "integrity": "sha512-Hm2gpMg/lRv4fKtiO2NfBiaJdFZVVb1V1a+IVhlD9qCuObLhCt60Oze2kD1dQzhbaIX756cs/eyxa5bQ5jihhQ==", "dev": true, "license": "MIT", "dependencies": { "@cspell/dict-ada": "^4.1.1", "@cspell/dict-al": "^1.1.1", - "@cspell/dict-aws": "^4.0.15", - "@cspell/dict-bash": "^4.2.1", - "@cspell/dict-companies": "^3.2.5", - "@cspell/dict-cpp": "^6.0.12", + "@cspell/dict-aws": "^4.0.16", + "@cspell/dict-bash": "^4.2.2", + "@cspell/dict-companies": "^3.2.7", + "@cspell/dict-cpp": "^6.0.15", "@cspell/dict-cryptocurrencies": "^5.0.5", "@cspell/dict-csharp": "^4.0.7", "@cspell/dict-css": "^4.0.18", "@cspell/dict-dart": "^2.3.1", - "@cspell/dict-data-science": "^2.0.9", + "@cspell/dict-data-science": "^2.0.12", "@cspell/dict-django": "^4.1.5", "@cspell/dict-docker": "^1.1.16", "@cspell/dict-dotnet": "^5.0.10", "@cspell/dict-elixir": "^4.0.8", - "@cspell/dict-en_us": "^4.4.18", - "@cspell/dict-en-common-misspellings": "^2.1.5", - "@cspell/dict-en-gb-mit": "^3.1.8", - "@cspell/dict-filetypes": "^3.0.13", + "@cspell/dict-en_us": "^4.4.24", + "@cspell/dict-en-common-misspellings": "^2.1.8", + "@cspell/dict-en-gb-mit": "^3.1.14", + "@cspell/dict-filetypes": "^3.0.14", "@cspell/dict-flutter": "^1.1.1", "@cspell/dict-fonts": "^4.0.5", "@cspell/dict-fsharp": "^1.1.1", "@cspell/dict-fullstack": "^3.2.7", "@cspell/dict-gaming-terms": "^1.1.2", "@cspell/dict-git": "^3.0.7", - "@cspell/dict-golang": "^6.0.23", + "@cspell/dict-golang": "^6.0.24", "@cspell/dict-google": "^1.0.9", "@cspell/dict-haskell": "^4.0.6", - "@cspell/dict-html": "^4.0.12", + "@cspell/dict-html": "^4.0.13", "@cspell/dict-html-symbol-entities": "^4.0.4", "@cspell/dict-java": "^5.0.12", "@cspell/dict-julia": "^1.1.1", @@ -351,48 +357,49 @@ "@cspell/dict-lorem-ipsum": "^4.0.5", "@cspell/dict-lua": "^4.0.8", "@cspell/dict-makefile": "^1.0.5", - "@cspell/dict-markdown": "^2.0.12", + "@cspell/dict-markdown": "^2.0.13", "@cspell/dict-monkeyc": "^1.0.11", "@cspell/dict-node": "^5.0.8", - "@cspell/dict-npm": "^5.2.15", - "@cspell/dict-php": "^4.0.15", + "@cspell/dict-npm": "^5.2.25", + "@cspell/dict-php": "^4.1.0", "@cspell/dict-powershell": "^5.0.15", "@cspell/dict-public-licenses": "^2.0.15", - "@cspell/dict-python": "^4.2.19", + "@cspell/dict-python": "^4.2.23", "@cspell/dict-r": "^2.1.1", "@cspell/dict-ruby": "^5.0.9", "@cspell/dict-rust": "^4.0.12", "@cspell/dict-scala": "^5.0.8", - "@cspell/dict-shell": "^1.1.1", - "@cspell/dict-software-terms": "^5.1.7", + "@cspell/dict-shell": "^1.1.2", + "@cspell/dict-software-terms": "^5.1.15", "@cspell/dict-sql": "^2.2.1", "@cspell/dict-svelte": "^1.0.7", "@cspell/dict-swift": "^2.0.6", "@cspell/dict-terraform": "^1.1.3", "@cspell/dict-typescript": "^3.2.3", - "@cspell/dict-vue": "^3.0.5" + "@cspell/dict-vue": "^3.0.5", + "@cspell/dict-zig": "^1.0.0" }, "engines": { "node": ">=20" } }, "node_modules/@cspell/cspell-json-reporter": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/@cspell/cspell-json-reporter/-/cspell-json-reporter-9.2.1.tgz", - "integrity": "sha512-LiiIWzLP9h2etKn0ap6g2+HrgOGcFEF/hp5D8ytmSL5sMxDcV13RrmJCEMTh1axGyW0SjQEFjPnYzNpCL1JjGA==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/@cspell/cspell-json-reporter/-/cspell-json-reporter-9.4.0.tgz", + "integrity": "sha512-TpHY7t13xNhcZF9bwOfgVIhcyPDamMnxU/TBYhf4mPtXPLrZ5gBTg3UZh0/9Zn3naMjmJtngdsLvB2wai9xBlQ==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/cspell-types": "9.2.1" + "@cspell/cspell-types": "9.4.0" }, "engines": { "node": ">=20" } }, "node_modules/@cspell/cspell-pipe": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/@cspell/cspell-pipe/-/cspell-pipe-9.2.1.tgz", - "integrity": "sha512-2N1H63If5cezLqKToY/YSXon4m4REg/CVTFZr040wlHRbbQMh5EF3c7tEC/ue3iKAQR4sm52ihfqo1n4X6kz+g==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/@cspell/cspell-pipe/-/cspell-pipe-9.4.0.tgz", + "integrity": "sha512-cI0sUe7SB99hJB1T6PhH/MpSrnml1kOekTCE+VH3Eb7zkVP5/mwJXs8BlufdvwBona+Cgkx6jeWlhFpxLc39Yg==", "dev": true, "license": "MIT", "engines": { @@ -400,9 +407,9 @@ } }, "node_modules/@cspell/cspell-resolver": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/@cspell/cspell-resolver/-/cspell-resolver-9.2.1.tgz", - "integrity": "sha512-fRPQ6GWU5eyh8LN1TZblc7t24TlGhJprdjJkfZ+HjQo+6ivdeBPT7pC7pew6vuMBQPS1oHBR36hE0ZnJqqkCeg==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/@cspell/cspell-resolver/-/cspell-resolver-9.4.0.tgz", + "integrity": "sha512-o9gbbdXlhxG2rqtGqQ7xZ8MGDDsPLbskBnTeuA++ix4Ch/HdjrBNmKReIGAEqJPfP+JGgoEKqFISHUDKAJ/ygQ==", "dev": true, "license": "MIT", "dependencies": { @@ -413,9 +420,9 @@ } }, "node_modules/@cspell/cspell-service-bus": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/@cspell/cspell-service-bus/-/cspell-service-bus-9.2.1.tgz", - "integrity": "sha512-k4M6bqdvWbcGSbcfLD7Lf4coZVObsISDW+sm/VaWp9aZ7/uwiz1IuGUxL9WO4JIdr9CFEf7Ivmvd2txZpVOCIA==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/@cspell/cspell-service-bus/-/cspell-service-bus-9.4.0.tgz", + "integrity": "sha512-UottRlFPN6FGUfojx5HtUPZTeYXg2rf2HvO/HLh0KicirVYO16vFxTevg9MyOvw1EXSsDRz8ECANjiE7fnzBCQ==", "dev": true, "license": "MIT", "engines": { @@ -423,9 +430,9 @@ } }, "node_modules/@cspell/cspell-types": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/@cspell/cspell-types/-/cspell-types-9.2.1.tgz", - "integrity": "sha512-FQHgQYdTHkcpxT0u1ddLIg5Cc5ePVDcLg9+b5Wgaubmc5I0tLotgYj8c/mvStWuKsuZIs6sUopjJrE91wk6Onw==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/@cspell/cspell-types/-/cspell-types-9.4.0.tgz", + "integrity": "sha512-vSpd50OfmthBH0aRFRLA2zJFtwli3ntHA0WAOJ8tIMLUCJgF3udooRXFeX3wR8ri69C9mc3864LC4inyRC/E9w==", "dev": true, "license": "MIT", "engines": { @@ -447,33 +454,33 @@ "license": "MIT" }, "node_modules/@cspell/dict-aws": { - "version": "4.0.15", - "resolved": "https://registry.npmjs.org/@cspell/dict-aws/-/dict-aws-4.0.15.tgz", - "integrity": "sha512-aPY7VVR5Os4rz36EaqXBAEy14wR4Rqv+leCJ2Ug/Gd0IglJpM30LalF3e2eJChnjje3vWoEC0Rz3+e5gpZG+Kg==", + "version": "4.0.17", + "resolved": "https://registry.npmjs.org/@cspell/dict-aws/-/dict-aws-4.0.17.tgz", + "integrity": "sha512-ORcblTWcdlGjIbWrgKF+8CNEBQiLVKdUOFoTn0KPNkAYnFcdPP0muT4892h7H4Xafh3j72wqB4/loQ6Nti9E/w==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-bash": { - "version": "4.2.1", - "resolved": "https://registry.npmjs.org/@cspell/dict-bash/-/dict-bash-4.2.1.tgz", - "integrity": "sha512-SBnzfAyEAZLI9KFS7DUG6Xc1vDFuLllY3jz0WHvmxe8/4xV3ufFE3fGxalTikc1VVeZgZmxYiABw4iGxVldYEg==", + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/@cspell/dict-bash/-/dict-bash-4.2.2.tgz", + "integrity": "sha512-kyWbwtX3TsCf5l49gGQIZkRLaB/P8g73GDRm41Zu8Mv51kjl2H7Au0TsEvHv7jzcsRLS6aUYaZv6Zsvk1fOz+Q==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/dict-shell": "1.1.1" + "@cspell/dict-shell": "1.1.2" } }, "node_modules/@cspell/dict-companies": { - "version": "3.2.5", - "resolved": "https://registry.npmjs.org/@cspell/dict-companies/-/dict-companies-3.2.5.tgz", - "integrity": "sha512-H51R0w7c6RwJJPqH7Gs65tzP6ouZsYDEHmmol6MIIk0kQaOIBuFP2B3vIxHLUr2EPRVFZsMW8Ni7NmVyaQlwsg==", + "version": "3.2.10", + "resolved": "https://registry.npmjs.org/@cspell/dict-companies/-/dict-companies-3.2.10.tgz", + "integrity": "sha512-bJ1qnO1DkTn7JYGXvxp8FRQc4yq6tRXnrII+jbP8hHmq5TX5o1Wu+rdfpoUQaMWTl6balRvcMYiINDesnpR9Bw==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-cpp": { - "version": "6.0.12", - "resolved": "https://registry.npmjs.org/@cspell/dict-cpp/-/dict-cpp-6.0.12.tgz", - "integrity": "sha512-N4NsCTttVpMqQEYbf0VQwCj6np+pJESov0WieCN7R/0aByz4+MXEiDieWWisaiVi8LbKzs1mEj4ZTw5K/6O2UQ==", + "version": "6.0.15", + "resolved": "https://registry.npmjs.org/@cspell/dict-cpp/-/dict-cpp-6.0.15.tgz", + "integrity": "sha512-N7MKK3llRNoBncygvrnLaGvmjo4xzVr5FbtAc9+MFGHK6/LeSySBupr1FM72XDaVSIsmBEe7sDYCHHwlI9Jb2w==", "dev": true, "license": "MIT" }, @@ -485,51 +492,51 @@ "license": "MIT" }, "node_modules/@cspell/dict-csharp": { - "version": "4.0.7", - "resolved": "https://registry.npmjs.org/@cspell/dict-csharp/-/dict-csharp-4.0.7.tgz", - "integrity": "sha512-H16Hpu8O/1/lgijFt2lOk4/nnldFtQ4t8QHbyqphqZZVE5aS4J/zD/WvduqnLY21aKhZS6jo/xF5PX9jyqPKUA==", + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/@cspell/dict-csharp/-/dict-csharp-4.0.8.tgz", + "integrity": "sha512-qmk45pKFHSxckl5mSlbHxmDitSsGMlk/XzFgt7emeTJWLNSTUK//MbYAkBNRtfzB4uD7pAFiKgpKgtJrTMRnrQ==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-css": { - "version": "4.0.18", - "resolved": "https://registry.npmjs.org/@cspell/dict-css/-/dict-css-4.0.18.tgz", - "integrity": "sha512-EF77RqROHL+4LhMGW5NTeKqfUd/e4OOv6EDFQ/UQQiFyWuqkEKyEz0NDILxOFxWUEVdjT2GQ2cC7t12B6pESwg==", + "version": "4.0.19", + "resolved": "https://registry.npmjs.org/@cspell/dict-css/-/dict-css-4.0.19.tgz", + "integrity": "sha512-VYHtPnZt/Zd/ATbW3rtexWpBnHUohUrQOHff/2JBhsVgxOrksAxJnLAO43Q1ayLJBJUUwNVo+RU0sx0aaysZfg==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-dart": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/@cspell/dict-dart/-/dict-dart-2.3.1.tgz", - "integrity": "sha512-xoiGnULEcWdodXI6EwVyqpZmpOoh8RA2Xk9BNdR7DLamV/QMvEYn8KJ7NlRiTSauJKPNkHHQ5EVHRM6sTS7jdg==", + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/@cspell/dict-dart/-/dict-dart-2.3.2.tgz", + "integrity": "sha512-sUiLW56t9gfZcu8iR/5EUg+KYyRD83Cjl3yjDEA2ApVuJvK1HhX+vn4e4k4YfjpUQMag8XO2AaRhARE09+/rqw==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-data-science": { - "version": "2.0.9", - "resolved": "https://registry.npmjs.org/@cspell/dict-data-science/-/dict-data-science-2.0.9.tgz", - "integrity": "sha512-wTOFMlxv06veIwKdXUwdGxrQcK44Zqs426m6JGgHIB/GqvieZQC5n0UI+tUm5OCxuNyo4OV6mylT4cRMjtKtWQ==", + "version": "2.0.13", + "resolved": "https://registry.npmjs.org/@cspell/dict-data-science/-/dict-data-science-2.0.13.tgz", + "integrity": "sha512-l1HMEhBJkPmw4I2YGVu2eBSKM89K9pVF+N6qIr5Uo5H3O979jVodtuwP8I7LyPrJnC6nz28oxeGRCLh9xC5CVA==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-django": { - "version": "4.1.5", - "resolved": "https://registry.npmjs.org/@cspell/dict-django/-/dict-django-4.1.5.tgz", - "integrity": "sha512-AvTWu99doU3T8ifoMYOMLW2CXKvyKLukPh1auOPwFGHzueWYvBBN+OxF8wF7XwjTBMMeRleVdLh3aWCDEX/ZWg==", + "version": "4.1.6", + "resolved": "https://registry.npmjs.org/@cspell/dict-django/-/dict-django-4.1.6.tgz", + "integrity": "sha512-SdbSFDGy9ulETqNz15oWv2+kpWLlk8DJYd573xhIkeRdcXOjskRuxjSZPKfW7O3NxN/KEf3gm3IevVOiNuFS+w==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-docker": { - "version": "1.1.16", - "resolved": "https://registry.npmjs.org/@cspell/dict-docker/-/dict-docker-1.1.16.tgz", - "integrity": "sha512-UiVQ5RmCg6j0qGIxrBnai3pIB+aYKL3zaJGvXk1O/ertTKJif9RZikKXCEgqhaCYMweM4fuLqWSVmw3hU164Iw==", + "version": "1.1.17", + "resolved": "https://registry.npmjs.org/@cspell/dict-docker/-/dict-docker-1.1.17.tgz", + "integrity": "sha512-OcnVTIpHIYYKhztNTyK8ShAnXTfnqs43hVH6p0py0wlcwRIXe5uj4f12n7zPf2CeBI7JAlPjEsV0Rlf4hbz/xQ==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-dotnet": { - "version": "5.0.10", - "resolved": "https://registry.npmjs.org/@cspell/dict-dotnet/-/dict-dotnet-5.0.10.tgz", - "integrity": "sha512-ooar8BP/RBNP1gzYfJPStKEmpWy4uv/7JCq6FOnJLeD1yyfG3d/LFMVMwiJo+XWz025cxtkM3wuaikBWzCqkmg==", + "version": "5.0.11", + "resolved": "https://registry.npmjs.org/@cspell/dict-dotnet/-/dict-dotnet-5.0.11.tgz", + "integrity": "sha512-LSVKhpFf/ASTWJcfYeS0Sykcl1gVMsv2Z5Eo0TnTMSTLV3738HH+66pIsjUTChqU6SF3gKPuCe6EOaRYqb/evA==", "dev": true, "license": "MIT" }, @@ -541,30 +548,30 @@ "license": "MIT" }, "node_modules/@cspell/dict-en_us": { - "version": "4.4.19", - "resolved": "https://registry.npmjs.org/@cspell/dict-en_us/-/dict-en_us-4.4.19.tgz", - "integrity": "sha512-JYYgzhGqSGuIMNY1cTlmq3zrNpehrExMHqLmLnSM2jEGFeHydlL+KLBwBYxMy4e73w+p1+o/rmAiGsMj9g3MCw==", + "version": "4.4.27", + "resolved": "https://registry.npmjs.org/@cspell/dict-en_us/-/dict-en_us-4.4.27.tgz", + "integrity": "sha512-0y4vH2i5cFmi8sxkc4OlD2IlnqDznOtKczm4h6jA288g5VVrm3bhkYK6vcB8b0CoRKtYWKet4VEmHBP1yI+Qfw==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-en-common-misspellings": { - "version": "2.1.6", - "resolved": "https://registry.npmjs.org/@cspell/dict-en-common-misspellings/-/dict-en-common-misspellings-2.1.6.tgz", - "integrity": "sha512-xV9yryOqZizbSqxRS7kSVRrxVEyWHUqwdY56IuT7eAWGyTCJNmitXzXa4p+AnEbhL+AB2WLynGVSbNoUC3ceFA==", + "version": "2.1.11", + "resolved": "https://registry.npmjs.org/@cspell/dict-en-common-misspellings/-/dict-en-common-misspellings-2.1.11.tgz", + "integrity": "sha512-2jcY494If1udvzd7MT2z/QH/RACUo/I02vIY4ttNdZhgYvUmRKhg8OBdrbzYo0lJOcc7XUb8rhIFQRHzxOSVeA==", "dev": true, "license": "CC BY-SA 4.0" }, "node_modules/@cspell/dict-en-gb-mit": { - "version": "3.1.9", - "resolved": "https://registry.npmjs.org/@cspell/dict-en-gb-mit/-/dict-en-gb-mit-3.1.9.tgz", - "integrity": "sha512-1lSnphnHTOxnpNLpPLg1XXv8df3hs4oL0LJ6dkQ0IqNROl8Jzl6PD55BDTlKy4YOAA76dJlePB0wyrxB+VVKbg==", + "version": "3.1.16", + "resolved": "https://registry.npmjs.org/@cspell/dict-en-gb-mit/-/dict-en-gb-mit-3.1.16.tgz", + "integrity": "sha512-4PPdapCJslytxAVJu35Mv97qDyGmAQxtDE790T2bWNhcqN6gvRVAc/eTRaXkUIf21q1xCxxNNqpH4VfMup69rQ==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-filetypes": { - "version": "3.0.13", - "resolved": "https://registry.npmjs.org/@cspell/dict-filetypes/-/dict-filetypes-3.0.13.tgz", - "integrity": "sha512-g6rnytIpQlMNKGJT1JKzWkC+b3xCliDKpQ3ANFSq++MnR4GaLiifaC4JkVON11Oh/UTplYOR1nY3BR4X30bswA==", + "version": "3.0.15", + "resolved": "https://registry.npmjs.org/@cspell/dict-filetypes/-/dict-filetypes-3.0.15.tgz", + "integrity": "sha512-uDMeqYlLlK476w/muEFQGBy9BdQWS0mQ7BJiy/iQv5XUWZxE2O54ZQd9nW8GyQMzAgoyg5SG4hf9l039Qt66oA==", "dev": true, "license": "MIT" }, @@ -611,9 +618,9 @@ "license": "MIT" }, "node_modules/@cspell/dict-golang": { - "version": "6.0.23", - "resolved": "https://registry.npmjs.org/@cspell/dict-golang/-/dict-golang-6.0.23.tgz", - "integrity": "sha512-oXqUh/9dDwcmVlfUF5bn3fYFqbUzC46lXFQmi5emB0vYsyQXdNWsqi6/yH3uE7bdRE21nP7Yo0mR1jjFNyLamg==", + "version": "6.0.26", + "resolved": "https://registry.npmjs.org/@cspell/dict-golang/-/dict-golang-6.0.26.tgz", + "integrity": "sha512-YKA7Xm5KeOd14v5SQ4ll6afe9VSy3a2DWM7L9uBq4u3lXToRBQ1W5PRa+/Q9udd+DTURyVVnQ+7b9cnOlNxaRg==", "dev": true, "license": "MIT" }, @@ -632,16 +639,16 @@ "license": "MIT" }, "node_modules/@cspell/dict-html": { - "version": "4.0.12", - "resolved": "https://registry.npmjs.org/@cspell/dict-html/-/dict-html-4.0.12.tgz", - "integrity": "sha512-JFffQ1dDVEyJq6tCDWv0r/RqkdSnV43P2F/3jJ9rwLgdsOIXwQbXrz6QDlvQLVvNSnORH9KjDtenFTGDyzfCaA==", + "version": "4.0.14", + "resolved": "https://registry.npmjs.org/@cspell/dict-html/-/dict-html-4.0.14.tgz", + "integrity": "sha512-2bf7n+kS92g+cMKV0wr9o/Oq9n8JzU7CcrB96gIh2GHgnF+0xDOqO2W/1KeFAqOfqosoOVE48t+4dnEMkkoJ2Q==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-html-symbol-entities": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/@cspell/dict-html-symbol-entities/-/dict-html-symbol-entities-4.0.4.tgz", - "integrity": "sha512-afea+0rGPDeOV9gdO06UW183Qg6wRhWVkgCFwiO3bDupAoyXRuvupbb5nUyqSTsLXIKL8u8uXQlJ9pkz07oVXw==", + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/@cspell/dict-html-symbol-entities/-/dict-html-symbol-entities-4.0.5.tgz", + "integrity": "sha512-429alTD4cE0FIwpMucvSN35Ld87HCyuM8mF731KU5Rm4Je2SG6hmVx7nkBsLyrmH3sQukTcr1GaiZsiEg8svPA==", "dev": true, "license": "MIT" }, @@ -702,22 +709,22 @@ "license": "MIT" }, "node_modules/@cspell/dict-markdown": { - "version": "2.0.12", - "resolved": "https://registry.npmjs.org/@cspell/dict-markdown/-/dict-markdown-2.0.12.tgz", - "integrity": "sha512-ufwoliPijAgWkD/ivAMC+A9QD895xKiJRF/fwwknQb7kt7NozTLKFAOBtXGPJAB4UjhGBpYEJVo2elQ0FCAH9A==", + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/@cspell/dict-markdown/-/dict-markdown-2.0.14.tgz", + "integrity": "sha512-uLKPNJsUcumMQTsZZgAK9RgDLyQhUz/uvbQTEkvF/Q4XfC1i/BnA8XrOrd0+Vp6+tPOKyA+omI5LRWfMu5K/Lw==", "dev": true, "license": "MIT", "peerDependencies": { - "@cspell/dict-css": "^4.0.18", - "@cspell/dict-html": "^4.0.12", - "@cspell/dict-html-symbol-entities": "^4.0.4", + "@cspell/dict-css": "^4.0.19", + "@cspell/dict-html": "^4.0.14", + "@cspell/dict-html-symbol-entities": "^4.0.5", "@cspell/dict-typescript": "^3.2.3" } }, "node_modules/@cspell/dict-monkeyc": { - "version": "1.0.11", - "resolved": "https://registry.npmjs.org/@cspell/dict-monkeyc/-/dict-monkeyc-1.0.11.tgz", - "integrity": "sha512-7Q1Ncu0urALI6dPTrEbSTd//UK0qjRBeaxhnm8uY5fgYNFYAG+u4gtnTIo59S6Bw5P++4H3DiIDYoQdY/lha8w==", + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/@cspell/dict-monkeyc/-/dict-monkeyc-1.0.12.tgz", + "integrity": "sha512-MN7Vs11TdP5mbdNFQP5x2Ac8zOBm97ARg6zM5Sb53YQt/eMvXOMvrep7+/+8NJXs0jkp70bBzjqU4APcqBFNAw==", "dev": true, "license": "MIT" }, @@ -729,16 +736,16 @@ "license": "MIT" }, "node_modules/@cspell/dict-npm": { - "version": "5.2.17", - "resolved": "https://registry.npmjs.org/@cspell/dict-npm/-/dict-npm-5.2.17.tgz", - "integrity": "sha512-0yp7lBXtN3CtxBrpvTu/yAuPdOHR2ucKzPxdppc3VKO068waZNpKikn1NZCzBS3dIAFGVITzUPtuTXxt9cxnSg==", + "version": "5.2.28", + "resolved": "https://registry.npmjs.org/@cspell/dict-npm/-/dict-npm-5.2.28.tgz", + "integrity": "sha512-tjnBjpIJsgYMTqNSrL5YlvFcXdtc7gkrL1ZI+MPSJSYOoJ78yeegS5UrIIbH3VrQtbNYSS8YhlEVF+xN0G4E8Q==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-php": { - "version": "4.0.15", - "resolved": "https://registry.npmjs.org/@cspell/dict-php/-/dict-php-4.0.15.tgz", - "integrity": "sha512-iepGB2gtToMWSTvybesn4/lUp4LwXcEm0s8vasJLP76WWVkq1zYjmeS+WAIzNgsuURyZ/9mGqhS0CWMuo74ODw==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/@cspell/dict-php/-/dict-php-4.1.1.tgz", + "integrity": "sha512-EXelI+4AftmdIGtA8HL8kr4WlUE11OqCSVlnIgZekmTkEGSZdYnkFdiJ5IANSALtlQ1mghKjz+OFqVs6yowgWA==", "dev": true, "license": "MIT" }, @@ -757,13 +764,13 @@ "license": "MIT" }, "node_modules/@cspell/dict-python": { - "version": "4.2.19", - "resolved": "https://registry.npmjs.org/@cspell/dict-python/-/dict-python-4.2.19.tgz", - "integrity": "sha512-9S2gTlgILp1eb6OJcVZeC8/Od83N8EqBSg5WHVpx97eMMJhifOzePkE0kDYjyHMtAFznCQTUu0iQEJohNQ5B0A==", + "version": "4.2.25", + "resolved": "https://registry.npmjs.org/@cspell/dict-python/-/dict-python-4.2.25.tgz", + "integrity": "sha512-hDdN0YhKgpbtZVRjQ2c8jk+n0wQdidAKj1Fk8w7KEHb3YlY5uPJ0mAKJk7AJKPNLOlILoUmN+HAVJz+cfSbWYg==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/dict-data-science": "^2.0.9" + "@cspell/dict-data-science": "^2.0.13" } }, "node_modules/@cspell/dict-r": { @@ -774,37 +781,37 @@ "license": "MIT" }, "node_modules/@cspell/dict-ruby": { - "version": "5.0.9", - "resolved": "https://registry.npmjs.org/@cspell/dict-ruby/-/dict-ruby-5.0.9.tgz", - "integrity": "sha512-H2vMcERMcANvQshAdrVx0XoWaNX8zmmiQN11dZZTQAZaNJ0xatdJoSqY8C8uhEMW89bfgpN+NQgGuDXW2vmXEw==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@cspell/dict-ruby/-/dict-ruby-5.1.0.tgz", + "integrity": "sha512-9PJQB3cfkBULrMLp5kSAcFPpzf8oz9vFN+QYZABhQwWkGbuzCIXSorHrmWSASlx4yejt3brjaWS57zZ/YL5ZQQ==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-rust": { - "version": "4.0.12", - "resolved": "https://registry.npmjs.org/@cspell/dict-rust/-/dict-rust-4.0.12.tgz", - "integrity": "sha512-z2QiH+q9UlNhobBJArvILRxV8Jz0pKIK7gqu4TgmEYyjiu1TvnGZ1tbYHeu9w3I/wOP6UMDoCBTty5AlYfW0mw==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/@cspell/dict-rust/-/dict-rust-4.1.0.tgz", + "integrity": "sha512-ysFxxKc3QjPWtPacbwxzz8sDOACHNShlhQpnBsDXAHN3LogmuBsQtfyuU30APqFjCOg9KwGciKYC/hcGxJCbiA==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-scala": { - "version": "5.0.8", - "resolved": "https://registry.npmjs.org/@cspell/dict-scala/-/dict-scala-5.0.8.tgz", - "integrity": "sha512-YdftVmumv8IZq9zu1gn2U7A4bfM2yj9Vaupydotyjuc+EEZZSqAafTpvW/jKLWji2TgybM1L2IhmV0s/Iv9BTw==", + "version": "5.0.9", + "resolved": "https://registry.npmjs.org/@cspell/dict-scala/-/dict-scala-5.0.9.tgz", + "integrity": "sha512-AjVcVAELgllybr1zk93CJ5wSUNu/Zb5kIubymR/GAYkMyBdYFCZ3Zbwn4Zz8GJlFFAbazABGOu0JPVbeY59vGg==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-shell": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/@cspell/dict-shell/-/dict-shell-1.1.1.tgz", - "integrity": "sha512-T37oYxE7OV1x/1D4/13Y8JZGa1QgDCXV7AVt3HLXjn0Fe3TaNDvf5sU0fGnXKmBPqFFrHdpD3uutAQb1dlp15g==", + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@cspell/dict-shell/-/dict-shell-1.1.2.tgz", + "integrity": "sha512-WqOUvnwcHK1X61wAfwyXq04cn7KYyskg90j4lLg3sGGKMW9Sq13hs91pqrjC44Q+lQLgCobrTkMDw9Wyl9nRFA==", "dev": true, "license": "MIT" }, "node_modules/@cspell/dict-software-terms": { - "version": "5.1.8", - "resolved": "https://registry.npmjs.org/@cspell/dict-software-terms/-/dict-software-terms-5.1.8.tgz", - "integrity": "sha512-iwCHLP11OmVHEX2MzE8EPxpPw7BelvldxWe5cJ3xXIDL8TjF2dBTs2noGcrqnZi15SLYIlO8897BIOa33WHHZA==", + "version": "5.1.19", + "resolved": "https://registry.npmjs.org/@cspell/dict-software-terms/-/dict-software-terms-5.1.19.tgz", + "integrity": "sha512-3leJLYvibbOnPsIUV/60WcSPxzRmgrx6/0QkqRi8cSsEuRY5/cbUU8Jc0/hKYCIhWJlnIWh5yx34Ep2s8QSIBw==", "dev": true, "license": "MIT" }, @@ -850,14 +857,21 @@ "dev": true, "license": "MIT" }, + "node_modules/@cspell/dict-zig": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@cspell/dict-zig/-/dict-zig-1.0.0.tgz", + "integrity": "sha512-XibBIxBlVosU06+M6uHWkFeT0/pW5WajDRYdXG2CgHnq85b0TI/Ks0FuBJykmsgi2CAD3Qtx8UHFEtl/DSFnAQ==", + "dev": true, + "license": "MIT" + }, "node_modules/@cspell/dynamic-import": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/@cspell/dynamic-import/-/dynamic-import-9.2.1.tgz", - "integrity": "sha512-izYQbk7ck0ffNA1gf7Gi3PkUEjj+crbYeyNK1hxHx5A+GuR416ozs0aEyp995KI2v9HZlXscOj3SC3wrWzHZeA==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/@cspell/dynamic-import/-/dynamic-import-9.4.0.tgz", + "integrity": "sha512-d2fjLjzrKGUIn5hWK8gMuyAh2pqXSxBqOHpU1jR3jxbrO3MilunKNijaSstv7CZn067Jpc36VfaKQodaXNZzUA==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/url": "9.2.1", + "@cspell/url": "9.4.0", "import-meta-resolve": "^4.2.0" }, "engines": { @@ -865,9 +879,9 @@ } }, "node_modules/@cspell/filetypes": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/@cspell/filetypes/-/filetypes-9.2.1.tgz", - "integrity": "sha512-Dy1y1pQ+7hi2gPs+jERczVkACtYbUHcLodXDrzpipoxgOtVxMcyZuo+84WYHImfu0gtM0wU2uLObaVgMSTnytw==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/@cspell/filetypes/-/filetypes-9.4.0.tgz", + "integrity": "sha512-RMrYHkvPF0tHVFM+T4voEhX9sfYQrd/mnNbf6+O4CWUyLCz4NQ5H9yOgEIJwEcLu4y3NESGXFef/Jn5xo0CUfg==", "dev": true, "license": "MIT", "engines": { @@ -875,9 +889,9 @@ } }, "node_modules/@cspell/strong-weak-map": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/@cspell/strong-weak-map/-/strong-weak-map-9.2.1.tgz", - "integrity": "sha512-1HsQWZexvJSjDocVnbeAWjjgqWE/0op/txxzDPvDqI2sE6pY0oO4Cinj2I8z+IP+m6/E6yjPxdb23ydbQbPpJQ==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/@cspell/strong-weak-map/-/strong-weak-map-9.4.0.tgz", + "integrity": "sha512-ui7mlXYmqElS/SmRubPBNWdkQVWgWbB6rjCurc+0owYXlnweItAMHTxC8mCWM/Au22SF1dB/JR8QBELFXLkTjQ==", "dev": true, "license": "MIT", "engines": { @@ -885,9 +899,9 @@ } }, "node_modules/@cspell/url": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/@cspell/url/-/url-9.2.1.tgz", - "integrity": "sha512-9EHCoGKtisPNsEdBQ28tKxKeBmiVS3D4j+AN8Yjr+Dmtu+YACKGWiMOddNZG2VejQNIdFx7FwzU00BGX68ELhA==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/@cspell/url/-/url-9.4.0.tgz", + "integrity": "sha512-nt88P6m20AaVbqMxsyPf8KqyWPaFEW2UANi0ijBxc2xTkD2KiUovxfZUYW6NMU9XBYZlovT5LztkEhst2yBcSA==", "dev": true, "license": "MIT", "engines": { @@ -895,9 +909,9 @@ } }, "node_modules/@esbuild/aix-ppc64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.9.tgz", - "integrity": "sha512-OaGtL73Jck6pBKjNIe24BnFE6agGl+6KxDtTfHhy1HmhthfKouEcOhqpSL64K4/0WCtbKFLOdzD/44cJ4k9opA==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz", + "integrity": "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==", "cpu": [ "ppc64" ], @@ -912,9 +926,9 @@ } }, "node_modules/@esbuild/android-arm": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.9.tgz", - "integrity": "sha512-5WNI1DaMtxQ7t7B6xa572XMXpHAaI/9Hnhk8lcxF4zVN4xstUgTlvuGDorBguKEnZO70qwEcLpfifMLoxiPqHQ==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.2.tgz", + "integrity": "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==", "cpu": [ "arm" ], @@ -929,9 +943,9 @@ } }, "node_modules/@esbuild/android-arm64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.9.tgz", - "integrity": "sha512-IDrddSmpSv51ftWslJMvl3Q2ZT98fUSL2/rlUXuVqRXHCs5EUF1/f+jbjF5+NG9UffUDMCiTyh8iec7u8RlTLg==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.2.tgz", + "integrity": "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==", "cpu": [ "arm64" ], @@ -946,9 +960,9 @@ } }, "node_modules/@esbuild/android-x64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.9.tgz", - "integrity": "sha512-I853iMZ1hWZdNllhVZKm34f4wErd4lMyeV7BLzEExGEIZYsOzqDWDf+y082izYUE8gtJnYHdeDpN/6tUdwvfiw==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.2.tgz", + "integrity": "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==", "cpu": [ "x64" ], @@ -963,9 +977,9 @@ } }, "node_modules/@esbuild/darwin-arm64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.9.tgz", - "integrity": "sha512-XIpIDMAjOELi/9PB30vEbVMs3GV1v2zkkPnuyRRURbhqjyzIINwj+nbQATh4H9GxUgH1kFsEyQMxwiLFKUS6Rg==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.2.tgz", + "integrity": "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==", "cpu": [ "arm64" ], @@ -980,9 +994,9 @@ } }, "node_modules/@esbuild/darwin-x64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.9.tgz", - "integrity": "sha512-jhHfBzjYTA1IQu8VyrjCX4ApJDnH+ez+IYVEoJHeqJm9VhG9Dh2BYaJritkYK3vMaXrf7Ogr/0MQ8/MeIefsPQ==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.2.tgz", + "integrity": "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==", "cpu": [ "x64" ], @@ -997,9 +1011,9 @@ } }, "node_modules/@esbuild/freebsd-arm64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.9.tgz", - "integrity": "sha512-z93DmbnY6fX9+KdD4Ue/H6sYs+bhFQJNCPZsi4XWJoYblUqT06MQUdBCpcSfuiN72AbqeBFu5LVQTjfXDE2A6Q==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.2.tgz", + "integrity": "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==", "cpu": [ "arm64" ], @@ -1014,9 +1028,9 @@ } }, "node_modules/@esbuild/freebsd-x64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.9.tgz", - "integrity": "sha512-mrKX6H/vOyo5v71YfXWJxLVxgy1kyt1MQaD8wZJgJfG4gq4DpQGpgTB74e5yBeQdyMTbgxp0YtNj7NuHN0PoZg==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.2.tgz", + "integrity": "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==", "cpu": [ "x64" ], @@ -1031,9 +1045,9 @@ } }, "node_modules/@esbuild/linux-arm": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.9.tgz", - "integrity": "sha512-HBU2Xv78SMgaydBmdor38lg8YDnFKSARg1Q6AT0/y2ezUAKiZvc211RDFHlEZRFNRVhcMamiToo7bDx3VEOYQw==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.2.tgz", + "integrity": "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==", "cpu": [ "arm" ], @@ -1048,9 +1062,9 @@ } }, "node_modules/@esbuild/linux-arm64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.9.tgz", - "integrity": "sha512-BlB7bIcLT3G26urh5Dmse7fiLmLXnRlopw4s8DalgZ8ef79Jj4aUcYbk90g8iCa2467HX8SAIidbL7gsqXHdRw==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.2.tgz", + "integrity": "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==", "cpu": [ "arm64" ], @@ -1065,9 +1079,9 @@ } }, "node_modules/@esbuild/linux-ia32": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.9.tgz", - "integrity": "sha512-e7S3MOJPZGp2QW6AK6+Ly81rC7oOSerQ+P8L0ta4FhVi+/j/v2yZzx5CqqDaWjtPFfYz21Vi1S0auHrap3Ma3A==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.2.tgz", + "integrity": "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==", "cpu": [ "ia32" ], @@ -1082,9 +1096,9 @@ } }, "node_modules/@esbuild/linux-loong64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.9.tgz", - "integrity": "sha512-Sbe10Bnn0oUAB2AalYztvGcK+o6YFFA/9829PhOCUS9vkJElXGdphz0A3DbMdP8gmKkqPmPcMJmJOrI3VYB1JQ==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.2.tgz", + "integrity": "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==", "cpu": [ "loong64" ], @@ -1099,9 +1113,9 @@ } }, "node_modules/@esbuild/linux-mips64el": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.9.tgz", - "integrity": "sha512-YcM5br0mVyZw2jcQeLIkhWtKPeVfAerES5PvOzaDxVtIyZ2NUBZKNLjC5z3/fUlDgT6w89VsxP2qzNipOaaDyA==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.2.tgz", + "integrity": "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==", "cpu": [ "mips64el" ], @@ -1116,9 +1130,9 @@ } }, "node_modules/@esbuild/linux-ppc64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.9.tgz", - "integrity": "sha512-++0HQvasdo20JytyDpFvQtNrEsAgNG2CY1CLMwGXfFTKGBGQT3bOeLSYE2l1fYdvML5KUuwn9Z8L1EWe2tzs1w==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.2.tgz", + "integrity": "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==", "cpu": [ "ppc64" ], @@ -1133,9 +1147,9 @@ } }, "node_modules/@esbuild/linux-riscv64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.9.tgz", - "integrity": "sha512-uNIBa279Y3fkjV+2cUjx36xkx7eSjb8IvnL01eXUKXez/CBHNRw5ekCGMPM0BcmqBxBcdgUWuUXmVWwm4CH9kg==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.2.tgz", + "integrity": "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==", "cpu": [ "riscv64" ], @@ -1150,9 +1164,9 @@ } }, "node_modules/@esbuild/linux-s390x": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.9.tgz", - "integrity": "sha512-Mfiphvp3MjC/lctb+7D287Xw1DGzqJPb/J2aHHcHxflUo+8tmN/6d4k6I2yFR7BVo5/g7x2Monq4+Yew0EHRIA==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.2.tgz", + "integrity": "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==", "cpu": [ "s390x" ], @@ -1167,9 +1181,9 @@ } }, "node_modules/@esbuild/linux-x64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.9.tgz", - "integrity": "sha512-iSwByxzRe48YVkmpbgoxVzn76BXjlYFXC7NvLYq+b+kDjyyk30J0JY47DIn8z1MO3K0oSl9fZoRmZPQI4Hklzg==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.2.tgz", + "integrity": "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==", "cpu": [ "x64" ], @@ -1184,9 +1198,9 @@ } }, "node_modules/@esbuild/netbsd-arm64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.9.tgz", - "integrity": "sha512-9jNJl6FqaUG+COdQMjSCGW4QiMHH88xWbvZ+kRVblZsWrkXlABuGdFJ1E9L7HK+T0Yqd4akKNa/lO0+jDxQD4Q==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.2.tgz", + "integrity": "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==", "cpu": [ "arm64" ], @@ -1201,9 +1215,9 @@ } }, "node_modules/@esbuild/netbsd-x64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.9.tgz", - "integrity": "sha512-RLLdkflmqRG8KanPGOU7Rpg829ZHu8nFy5Pqdi9U01VYtG9Y0zOG6Vr2z4/S+/3zIyOxiK6cCeYNWOFR9QP87g==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.2.tgz", + "integrity": "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==", "cpu": [ "x64" ], @@ -1218,9 +1232,9 @@ } }, "node_modules/@esbuild/openbsd-arm64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.9.tgz", - "integrity": "sha512-YaFBlPGeDasft5IIM+CQAhJAqS3St3nJzDEgsgFixcfZeyGPCd6eJBWzke5piZuZ7CtL656eOSYKk4Ls2C0FRQ==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.2.tgz", + "integrity": "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==", "cpu": [ "arm64" ], @@ -1235,9 +1249,9 @@ } }, "node_modules/@esbuild/openbsd-x64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.9.tgz", - "integrity": "sha512-1MkgTCuvMGWuqVtAvkpkXFmtL8XhWy+j4jaSO2wxfJtilVCi0ZE37b8uOdMItIHz4I6z1bWWtEX4CJwcKYLcuA==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.2.tgz", + "integrity": "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==", "cpu": [ "x64" ], @@ -1252,9 +1266,9 @@ } }, "node_modules/@esbuild/openharmony-arm64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.9.tgz", - "integrity": "sha512-4Xd0xNiMVXKh6Fa7HEJQbrpP3m3DDn43jKxMjxLLRjWnRsfxjORYJlXPO4JNcXtOyfajXorRKY9NkOpTHptErg==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.2.tgz", + "integrity": "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==", "cpu": [ "arm64" ], @@ -1269,9 +1283,9 @@ } }, "node_modules/@esbuild/sunos-x64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.9.tgz", - "integrity": "sha512-WjH4s6hzo00nNezhp3wFIAfmGZ8U7KtrJNlFMRKxiI9mxEK1scOMAaa9i4crUtu+tBr+0IN6JCuAcSBJZfnphw==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.2.tgz", + "integrity": "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==", "cpu": [ "x64" ], @@ -1286,9 +1300,9 @@ } }, "node_modules/@esbuild/win32-arm64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.9.tgz", - "integrity": "sha512-mGFrVJHmZiRqmP8xFOc6b84/7xa5y5YvR1x8djzXpJBSv/UsNK6aqec+6JDjConTgvvQefdGhFDAs2DLAds6gQ==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.2.tgz", + "integrity": "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==", "cpu": [ "arm64" ], @@ -1303,9 +1317,9 @@ } }, "node_modules/@esbuild/win32-ia32": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.9.tgz", - "integrity": "sha512-b33gLVU2k11nVx1OhX3C8QQP6UHQK4ZtN56oFWvVXvz2VkDoe6fbG8TOgHFxEvqeqohmRnIHe5A1+HADk4OQww==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.2.tgz", + "integrity": "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==", "cpu": [ "ia32" ], @@ -1320,9 +1334,9 @@ } }, "node_modules/@esbuild/win32-x64": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.9.tgz", - "integrity": "sha512-PPOl1mi6lpLNQxnGoyAfschAodRFYXJ+9fs6WHXz7CSWKbOqiMZsubC+BQsVKuul+3vKLuwTHsS2c2y9EoKwxQ==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.2.tgz", + "integrity": "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==", "cpu": [ "x64" ], @@ -1337,10 +1351,11 @@ } }, "node_modules/@eslint-community/eslint-utils": { - "version": "4.7.0", - "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz", - "integrity": "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==", + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz", + "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==", "dev": true, + "license": "MIT", "dependencies": { "eslint-visitor-keys": "^3.4.3" }, @@ -1355,21 +1370,23 @@ } }, "node_modules/@eslint-community/regexpp": { - "version": "4.12.1", - "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz", - "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==", + "version": "4.12.2", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", + "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", "dev": true, + "license": "MIT", "engines": { "node": "^12.0.0 || ^14.0.0 || >=16.0.0" } }, "node_modules/@eslint/config-array": { - "version": "0.20.0", - "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.20.0.tgz", - "integrity": "sha512-fxlS1kkIjx8+vy2SjuCB94q3htSNrufYTXubwiBFeaQHbH6Ipi43gFJq2zCMt6PHhImH3Xmr0NksKDvchWlpQQ==", + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz", + "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==", "dev": true, + "license": "Apache-2.0", "dependencies": { - "@eslint/object-schema": "^2.1.6", + "@eslint/object-schema": "^2.1.7", "debug": "^4.3.1", "minimatch": "^3.1.2" }, @@ -1393,6 +1410,7 @@ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "dev": true, + "license": "ISC", "dependencies": { "brace-expansion": "^1.1.7" }, @@ -1401,19 +1419,24 @@ } }, "node_modules/@eslint/config-helpers": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.2.2.tgz", - "integrity": "sha512-+GPzk8PlG0sPpzdU5ZvIRMPidzAnZDl/s9L+y13iodqvb8leL53bTannOrQ/Im7UkpsmFU5Ily5U60LWixnmLg==", + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz", + "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==", "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0" + }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" } }, "node_modules/@eslint/core": { - "version": "0.14.0", - "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.14.0.tgz", - "integrity": "sha512-qIbV0/JZr7iSDjqAc60IqbLdsj9GDt16xQtWD+B78d/HAlvysGdZZ6rpJHGAc2T0FQx1X6thsSPdnoiGKdNtdg==", + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz", + "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==", "dev": true, + "license": "Apache-2.0", "dependencies": { "@types/json-schema": "^7.0.15" }, @@ -1422,10 +1445,11 @@ } }, "node_modules/@eslint/eslintrc": { - "version": "3.3.1", - "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.1.tgz", - "integrity": "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==", + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.3.tgz", + "integrity": "sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==", "dev": true, + "license": "MIT", "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", @@ -1433,7 +1457,7 @@ "globals": "^14.0.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", - "js-yaml": "^4.1.0", + "js-yaml": "^4.1.1", "minimatch": "^3.1.2", "strip-json-comments": "^3.1.1" }, @@ -1444,6 +1468,23 @@ "url": "https://opencollective.com/eslint" } }, + "node_modules/@eslint/eslintrc/node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, "node_modules/@eslint/eslintrc/node_modules/brace-expansion": { "version": "1.1.12", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", @@ -1473,15 +1514,24 @@ "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", "dev": true, + "license": "MIT", "engines": { "node": ">= 4" } }, + "node_modules/@eslint/eslintrc/node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, "node_modules/@eslint/eslintrc/node_modules/minimatch": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "dev": true, + "license": "ISC", "dependencies": { "brace-expansion": "^1.1.7" }, @@ -1490,9 +1540,9 @@ } }, "node_modules/@eslint/js": { - "version": "9.27.0", - "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.27.0.tgz", - "integrity": "sha512-G5JD9Tu5HJEu4z2Uo4aHY2sLV64B7CDMXxFzqzjl3NKd6RVzSXNoE80jk7Y0lJkTTkjiIhBAqmlYwjuBY3tvpA==", + "version": "9.39.2", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.2.tgz", + "integrity": "sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==", "dev": true, "license": "MIT", "engines": { @@ -1503,21 +1553,23 @@ } }, "node_modules/@eslint/object-schema": { - "version": "2.1.6", - "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.6.tgz", - "integrity": "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==", + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz", + "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" } }, "node_modules/@eslint/plugin-kit": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.3.1.tgz", - "integrity": "sha512-0J+zgWxHN+xXONWIyPWKFMgVuJoZuGiIFu8yxk7RJjxkzpGmyja5wRFqZIVtjDVOQpV+Rw0iOAjYPE2eQyjr0w==", + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz", + "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==", "dev": true, + "license": "Apache-2.0", "dependencies": { - "@eslint/core": "^0.14.0", + "@eslint/core": "^0.17.0", "levn": "^0.4.1" }, "engines": { @@ -1525,9 +1577,9 @@ } }, "node_modules/@grpc/grpc-js": { - "version": "1.14.0", - "resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.14.0.tgz", - "integrity": "sha512-N8Jx6PaYzcTRNzirReJCtADVoq4z7+1KQ4E70jTg/koQiMoUSN1kbNjPOqpPbhMFhfU1/l7ixspPl8dNY+FoUg==", + "version": "1.14.3", + "resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.14.3.tgz", + "integrity": "sha512-Iq8QQQ/7X3Sac15oB6p0FmUg/klxQvXLeileoqrTRGJYLV+/9tubbr9ipz0GKHjmXVsgFPo/+W+2cA8eNcR+XA==", "license": "Apache-2.0", "dependencies": { "@grpc/proto-loader": "^0.8.0", @@ -1555,46 +1607,48 @@ "node": ">=6" } }, + "node_modules/@hono/node-server": { + "version": "1.19.7", + "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.7.tgz", + "integrity": "sha512-vUcD0uauS7EU2caukW8z5lJKtoGMokxNbJtBiwHgpqxEXokaHCBkQUmCHhjFB1VUTWdqj25QoMkMKzgjq+uhrw==", + "license": "MIT", + "engines": { + "node": ">=18.14.1" + }, + "peerDependencies": { + "hono": "^4" + } + }, "node_modules/@humanfs/core": { "version": "0.19.1", "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz", "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==", "dev": true, + "license": "Apache-2.0", "engines": { "node": ">=18.18.0" } }, "node_modules/@humanfs/node": { - "version": "0.16.6", - "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.6.tgz", - "integrity": "sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==", + "version": "0.16.7", + "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz", + "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==", "dev": true, + "license": "Apache-2.0", "dependencies": { "@humanfs/core": "^0.19.1", - "@humanwhocodes/retry": "^0.3.0" + "@humanwhocodes/retry": "^0.4.0" }, "engines": { "node": ">=18.18.0" } }, - "node_modules/@humanfs/node/node_modules/@humanwhocodes/retry": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.3.1.tgz", - "integrity": "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==", - "dev": true, - "engines": { - "node": ">=18.18" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/nzakas" - } - }, "node_modules/@humanwhocodes/module-importer": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", "dev": true, + "license": "Apache-2.0", "engines": { "node": ">=12.22" }, @@ -1608,6 +1662,7 @@ "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz", "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", "dev": true, + "license": "Apache-2.0", "engines": { "node": ">=18.18" }, @@ -1616,10 +1671,32 @@ "url": "https://github.com/sponsors/nzakas" } }, + "node_modules/@inquirer/external-editor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@inquirer/external-editor/-/external-editor-1.0.3.tgz", + "integrity": "sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==", + "dev": true, + "license": "MIT", + "dependencies": { + "chardet": "^2.1.1", + "iconv-lite": "^0.7.0" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, "node_modules/@inquirer/figures": { - "version": "1.0.12", - "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-1.0.12.tgz", - "integrity": "sha512-MJttijd8rMFcKJC8NYmprWr6hD3r9Gd9qUC0XwPNwoEPWSMVJwA2MlXxF+nhZZNMY+HXsWa+o7KY2emWYIn0jQ==", + "version": "1.0.15", + "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-1.0.15.tgz", + "integrity": "sha512-t2IEY+unGHOzAaVM5Xx6DEWKeXlDDcNPeDyUpsRc6CUhBfU3VQOEl+Vssh7VNp1dR8MdUJBWhuObjXCsVpjN5g==", "dev": true, "license": "MIT", "engines": { @@ -1667,32 +1744,6 @@ "node": ">=12" } }, - "node_modules/@isaacs/cliui/node_modules/ansi-regex": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.0.tgz", - "integrity": "sha512-TKY5pyBkHyADOPYlRT9Lx6F544mPl0vS5Ew7BJ45hA08Q+t3GjbueLliBWN3sMICk6+y7HdyxSzC4bWS8baBdg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/chalk/ansi-regex?sponsor=1" - } - }, - "node_modules/@isaacs/cliui/node_modules/ansi-styles": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", - "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/chalk/ansi-styles?sponsor=1" - } - }, "node_modules/@isaacs/cliui/node_modules/emoji-regex": { "version": "9.2.2", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", @@ -1718,22 +1769,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/@isaacs/cliui/node_modules/strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "ansi-regex": "^6.0.1" - }, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/chalk/strip-ansi?sponsor=1" - } - }, "node_modules/@isaacs/cliui/node_modules/wrap-ansi": { "version": "8.1.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", @@ -1757,22 +1792,31 @@ "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/@jridgewell/gen-mapping": { - "version": "0.3.8", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz", - "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==", + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", "dev": true, + "license": "MIT", "dependencies": { - "@jridgewell/set-array": "^1.2.1", - "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" - }, - "engines": { - "node": ">=6.0.0" } }, "node_modules/@jridgewell/resolve-uri": { @@ -1780,15 +1824,7 @@ "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", "dev": true, - "engines": { - "node": ">=6.0.0" - } - }, - "node_modules/@jridgewell/set-array": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz", - "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==", - "dev": true, + "license": "MIT", "engines": { "node": ">=6.0.0" } @@ -1801,10 +1837,11 @@ "license": "MIT" }, "node_modules/@jridgewell/trace-mapping": { - "version": "0.3.25", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", - "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", "dev": true, + "license": "MIT", "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" @@ -1821,20 +1858,67 @@ } }, "node_modules/@mcp-ui/server": { - "version": "5.13.1", - "resolved": "https://registry.npmjs.org/@mcp-ui/server/-/server-5.13.1.tgz", - "integrity": "sha512-jTHy8MTa+Cppw80mFID5ranw+CrmePpncIub726PGg38WETGR8tg7CW0mD9YS6pBdRL+A+EDNCiGbVlPjDfQHA==", + "version": "5.16.3", + "resolved": "https://registry.npmjs.org/@mcp-ui/server/-/server-5.16.3.tgz", + "integrity": "sha512-MZttML9tQC1B8f4SPgoT1BORfCDXqs4Ywb/mQ0wSwIYS9AuIWFLj1KXmvqC/zrG0SlNMlyvMSxEX/eVYsIoZaA==", "license": "Apache-2.0", "dependencies": { - "@modelcontextprotocol/sdk": "*" + "@modelcontextprotocol/ext-apps": "^0.2.2", + "@modelcontextprotocol/sdk": "^1.25.1" + } + }, + "node_modules/@modelcontextprotocol/ext-apps": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/@modelcontextprotocol/ext-apps/-/ext-apps-0.2.2.tgz", + "integrity": "sha512-h8sN3QIBLqMsRXjKL76M5VmBQf3N0I1G1DiDiSYAgtdynYQctHqCs79WEo1d5wClyZVYBWXdRcxgiR/WBfSOqw==", + "hasInstallScript": true, + "license": "MIT", + "workspaces": [ + "examples/*" + ], + "dependencies": { + "prettier": "^3.6.2" + }, + "optionalDependencies": { + "@oven/bun-darwin-aarch64": "^1.2.21", + "@oven/bun-darwin-x64": "^1.2.21", + "@oven/bun-darwin-x64-baseline": "^1.2.21", + "@oven/bun-linux-aarch64": "^1.2.21", + "@oven/bun-linux-aarch64-musl": "^1.2.21", + "@oven/bun-linux-x64": "^1.2.21", + "@oven/bun-linux-x64-baseline": "^1.2.21", + "@oven/bun-linux-x64-musl": "^1.2.21", + "@oven/bun-linux-x64-musl-baseline": "^1.2.21", + "@oven/bun-windows-x64": "^1.2.21", + "@oven/bun-windows-x64-baseline": "^1.2.21", + "@rollup/rollup-darwin-arm64": "^4.53.3", + "@rollup/rollup-darwin-x64": "^4.53.3", + "@rollup/rollup-linux-arm64-gnu": "^4.53.3", + "@rollup/rollup-linux-x64-gnu": "^4.53.3", + "@rollup/rollup-win32-x64-msvc": "^4.53.3" + }, + "peerDependencies": { + "@modelcontextprotocol/sdk": "^1.24.0", + "react": "^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0", + "zod": "^3.25.0 || ^4.0.0" + }, + "peerDependenciesMeta": { + "react": { + "optional": true + }, + "react-dom": { + "optional": true + } } }, "node_modules/@modelcontextprotocol/sdk": { - "version": "1.21.1", - "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.21.1.tgz", - "integrity": "sha512-UyLFcJLDvUuZbGnaQqXFT32CpPpGj7VS19roLut6gkQVhb439xUzYWbsUvdI3ZPL+2hnFosuugtYWE0Mcs1rmQ==", + "version": "1.25.1", + "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.25.1.tgz", + "integrity": "sha512-yO28oVFFC7EBoiKdAn+VqRm+plcfv4v0xp6osG/VsCB0NlPZWi87ajbCZZ8f/RvOFLEu7//rSRmuZZ7lMoe3gQ==", "license": "MIT", "dependencies": { + "@hono/node-server": "^1.19.7", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", @@ -1844,80 +1928,29 @@ "eventsource-parser": "^3.0.0", "express": "^5.0.1", "express-rate-limit": "^7.5.0", + "jose": "^6.1.1", + "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", - "zod": "^3.23.8", - "zod-to-json-schema": "^3.24.1" + "zod": "^3.25 || ^4.0", + "zod-to-json-schema": "^3.25.0" }, "engines": { "node": ">=18" }, "peerDependencies": { - "@cfworker/json-schema": "^4.1.1" + "@cfworker/json-schema": "^4.1.1", + "zod": "^3.25 || ^4.0" }, "peerDependenciesMeta": { "@cfworker/json-schema": { "optional": true + }, + "zod": { + "optional": false } } }, - "node_modules/@modelcontextprotocol/sdk/node_modules/ajv": { - "version": "8.17.1", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz", - "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==", - "license": "MIT", - "dependencies": { - "fast-deep-equal": "^3.1.3", - "fast-uri": "^3.0.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/epoberezkin" - } - }, - "node_modules/@modelcontextprotocol/sdk/node_modules/json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", - "license": "MIT" - }, - "node_modules/@nodelib/fs.scandir": { - "version": "2.1.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", - "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", - "dev": true, - "dependencies": { - "@nodelib/fs.stat": "2.0.5", - "run-parallel": "^1.1.9" - }, - "engines": { - "node": ">= 8" - } - }, - "node_modules/@nodelib/fs.stat": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", - "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", - "dev": true, - "engines": { - "node": ">= 8" - } - }, - "node_modules/@nodelib/fs.walk": { - "version": "1.2.8", - "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", - "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", - "dev": true, - "dependencies": { - "@nodelib/fs.scandir": "2.1.5", - "fastq": "^1.6.0" - }, - "engines": { - "node": ">= 8" - } - }, "node_modules/@opentelemetry/api": { "version": "1.9.0", "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz", @@ -5693,9 +5726,9 @@ } }, "node_modules/@opentelemetry/semantic-conventions": { - "version": "1.37.0", - "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.37.0.tgz", - "integrity": "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA==", + "version": "1.38.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.38.0.tgz", + "integrity": "sha512-kocjix+/sSggfJhwXqClZ3i9Y/MI0fp7b+g7kCRm6psy2dsf8uApTRclwG18h8Avm7C9+fnt+O36PspJ/OzoWg==", "license": "Apache-2.0", "engines": { "node": ">=14" @@ -5716,15 +5749,158 @@ "@opentelemetry/api": "^1.1.0" } }, - "node_modules/@pkgjs/parseargs": { - "version": "0.11.0", - "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", - "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", - "dev": true, + "node_modules/@oven/bun-darwin-aarch64": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-darwin-aarch64/-/bun-darwin-aarch64-1.3.5.tgz", + "integrity": "sha512-8GvNtMo0NINM7Emk9cNAviCG3teEgr3BUX9be0+GD029zIagx2Sf54jMui1Eu1IpFm7nWHODuLEefGOQNaJ0gQ==", + "cpu": [ + "arm64" + ], "license": "MIT", "optional": true, - "engines": { - "node": ">=14" + "os": [ + "darwin" + ] + }, + "node_modules/@oven/bun-darwin-x64": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-darwin-x64/-/bun-darwin-x64-1.3.5.tgz", + "integrity": "sha512-r33eHQOHAwkuiBJIwmkXIyqONQOQMnd1GMTpDzaxx9vf9+svby80LZO9Hcm1ns6KT/TBRFyODC/0loA7FAaffg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@oven/bun-darwin-x64-baseline": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-darwin-x64-baseline/-/bun-darwin-x64-baseline-1.3.5.tgz", + "integrity": "sha512-p5q3rJk48qhLuLBOFehVc+kqCE03YrswTc6NCxbwsxiwfySXwcAvpF2KWKF/ZZObvvR8hCCvqe1F81b2p5r2dg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@oven/bun-linux-aarch64": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-linux-aarch64/-/bun-linux-aarch64-1.3.5.tgz", + "integrity": "sha512-zkcHPI23QxJ1TdqafhgkXt1NOEN8o5C460sVeNnrhfJ43LwZgtfcvcQE39x/pBedu67fatY8CU0iY00nOh46ZQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@oven/bun-linux-aarch64-musl": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-linux-aarch64-musl/-/bun-linux-aarch64-musl-1.3.5.tgz", + "integrity": "sha512-HKBeUlJdNduRkzJKZ5DXM+pPqntfC50/Hu2X65jVX0Y7hu/6IC8RaUTqpr8FtCZqqmc9wDK0OTL+Mbi9UQIKYQ==", + "cpu": [ + "arm64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@oven/bun-linux-x64": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-linux-x64/-/bun-linux-x64-1.3.5.tgz", + "integrity": "sha512-n7zhKTSDZS0yOYg5Rq8easZu5Y/o47sv0c7yGr2ciFdcie9uYV55fZ7QMqhWMGK33ezCSikh5EDkUMCIvfWpjA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@oven/bun-linux-x64-baseline": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-linux-x64-baseline/-/bun-linux-x64-baseline-1.3.5.tgz", + "integrity": "sha512-FeCQyBU62DMuB0nn01vPnf3McXrKOsrK9p7sHaBFYycw0mmoU8kCq/WkBkGMnLuvQljJSyen8QBTx+fXdNupWg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@oven/bun-linux-x64-musl": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-linux-x64-musl/-/bun-linux-x64-musl-1.3.5.tgz", + "integrity": "sha512-XkCCHkByYn8BIDvoxnny898znju4xnW2kvFE8FT5+0Y62cWdcBGMZ9RdsEUTeRz16k8hHtJpaSfLcEmNTFIwRQ==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@oven/bun-linux-x64-musl-baseline": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-linux-x64-musl-baseline/-/bun-linux-x64-musl-baseline-1.3.5.tgz", + "integrity": "sha512-TJiYC7KCr0XxFTsxgwQOeE7dncrEL/RSyL0EzSL3xRkrxJMWBCvCSjQn7LV1i6T7hFst0+3KoN3VWvD5BinqHA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@oven/bun-windows-x64": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-windows-x64/-/bun-windows-x64-1.3.5.tgz", + "integrity": "sha512-T3xkODItb/0ftQPFsZDc7EAX2D6A4TEazQ2YZyofZToO8Q7y8YT8ooWdhd0BQiTCd66uEvgE1DCZetynwg2IoA==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@oven/bun-windows-x64-baseline": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@oven/bun-windows-x64-baseline/-/bun-windows-x64-baseline-1.3.5.tgz", + "integrity": "sha512-rtVQB9/1XK8FWJgFtsOthbPifRMYypgJwxu+pK3NHx8WvFKmq7HcPDqNr8xLzGULjQEO7eAo2aOZfONOwYz+5g==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@pkgjs/parseargs": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=14" } }, "node_modules/@pkgr/core": { @@ -5805,9 +5981,9 @@ "license": "BSD-3-Clause" }, "node_modules/@rollup/rollup-android-arm-eabi": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.50.0.tgz", - "integrity": "sha512-lVgpeQyy4fWN5QYebtW4buT/4kn4p4IJ+kDNB4uYNT5b8c8DLJDg6titg20NIg7E8RWwdWZORW6vUFfrLyG3KQ==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.55.1.tgz", + "integrity": "sha512-9R0DM/ykwfGIlNu6+2U09ga0WXeZ9MRC2Ter8jnz8415VbuIykVuc6bhdrbORFZANDmTDvq26mJrEVTl8TdnDg==", "cpu": [ "arm" ], @@ -5819,9 +5995,9 @@ ] }, "node_modules/@rollup/rollup-android-arm64": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.50.0.tgz", - "integrity": "sha512-2O73dR4Dc9bp+wSYhviP6sDziurB5/HCym7xILKifWdE9UsOe2FtNcM+I4xZjKrfLJnq5UR8k9riB87gauiQtw==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.55.1.tgz", + "integrity": "sha512-eFZCb1YUqhTysgW3sj/55du5cG57S7UTNtdMjCW7LwVcj3dTTcowCsC8p7uBdzKsZYa8J7IDE8lhMI+HX1vQvg==", "cpu": [ "arm64" ], @@ -5833,13 +6009,12 @@ ] }, "node_modules/@rollup/rollup-darwin-arm64": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.50.0.tgz", - "integrity": "sha512-vwSXQN8T4sKf1RHr1F0s98Pf8UPz7pS6P3LG9NSmuw0TVh7EmaE+5Ny7hJOZ0M2yuTctEsHHRTMi2wuHkdS6Hg==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.55.1.tgz", + "integrity": "sha512-p3grE2PHcQm2e8PSGZdzIhCKbMCw/xi9XvMPErPhwO17vxtvCN5FEA2mSLgmKlCjHGMQTP6phuQTYWUnKewwGg==", "cpu": [ "arm64" ], - "dev": true, "license": "MIT", "optional": true, "os": [ @@ -5847,13 +6022,12 @@ ] }, "node_modules/@rollup/rollup-darwin-x64": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.50.0.tgz", - "integrity": "sha512-cQp/WG8HE7BCGyFVuzUg0FNmupxC+EPZEwWu2FCGGw5WDT1o2/YlENbm5e9SMvfDFR6FRhVCBePLqj0o8MN7Vw==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.55.1.tgz", + "integrity": "sha512-rDUjG25C9qoTm+e02Esi+aqTKSBYwVTaoS1wxcN47/Luqef57Vgp96xNANwt5npq9GDxsH7kXxNkJVEsWEOEaQ==", "cpu": [ "x64" ], - "dev": true, "license": "MIT", "optional": true, "os": [ @@ -5861,9 +6035,9 @@ ] }, "node_modules/@rollup/rollup-freebsd-arm64": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.50.0.tgz", - "integrity": "sha512-UR1uTJFU/p801DvvBbtDD7z9mQL8J80xB0bR7DqW7UGQHRm/OaKzp4is7sQSdbt2pjjSS72eAtRh43hNduTnnQ==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.55.1.tgz", + "integrity": "sha512-+JiU7Jbp5cdxekIgdte0jfcu5oqw4GCKr6i3PJTlXTCU5H5Fvtkpbs4XJHRmWNXF+hKmn4v7ogI5OQPaupJgOg==", "cpu": [ "arm64" ], @@ -5875,9 +6049,9 @@ ] }, "node_modules/@rollup/rollup-freebsd-x64": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.50.0.tgz", - "integrity": "sha512-G/DKyS6PK0dD0+VEzH/6n/hWDNPDZSMBmqsElWnCRGrYOb2jC0VSupp7UAHHQ4+QILwkxSMaYIbQ72dktp8pKA==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.55.1.tgz", + "integrity": "sha512-V5xC1tOVWtLLmr3YUk2f6EJK4qksksOYiz/TCsFHu/R+woubcLWdC9nZQmwjOAbmExBIVKsm1/wKmEy4z4u4Bw==", "cpu": [ "x64" ], @@ -5889,9 +6063,9 @@ ] }, "node_modules/@rollup/rollup-linux-arm-gnueabihf": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.50.0.tgz", - "integrity": "sha512-u72Mzc6jyJwKjJbZZcIYmd9bumJu7KNmHYdue43vT1rXPm2rITwmPWF0mmPzLm9/vJWxIRbao/jrQmxTO0Sm9w==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.55.1.tgz", + "integrity": "sha512-Rn3n+FUk2J5VWx+ywrG/HGPTD9jXNbicRtTM11e/uorplArnXZYsVifnPPqNNP5BsO3roI4n8332ukpY/zN7rQ==", "cpu": [ "arm" ], @@ -5903,9 +6077,9 @@ ] }, "node_modules/@rollup/rollup-linux-arm-musleabihf": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.50.0.tgz", - "integrity": "sha512-S4UefYdV0tnynDJV1mdkNawp0E5Qm2MtSs330IyHgaccOFrwqsvgigUD29uT+B/70PDY1eQ3t40+xf6wIvXJyg==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.55.1.tgz", + "integrity": "sha512-grPNWydeKtc1aEdrJDWk4opD7nFtQbMmV7769hiAaYyUKCT1faPRm2av8CX1YJsZ4TLAZcg9gTR1KvEzoLjXkg==", "cpu": [ "arm" ], @@ -5917,13 +6091,12 @@ ] }, "node_modules/@rollup/rollup-linux-arm64-gnu": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.50.0.tgz", - "integrity": "sha512-1EhkSvUQXJsIhk4msxP5nNAUWoB4MFDHhtc4gAYvnqoHlaL9V3F37pNHabndawsfy/Tp7BPiy/aSa6XBYbaD1g==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.55.1.tgz", + "integrity": "sha512-a59mwd1k6x8tXKcUxSyISiquLwB5pX+fJW9TkWU46lCqD/GRDe9uDN31jrMmVP3feI3mhAdvcCClhV8V5MhJFQ==", "cpu": [ "arm64" ], - "dev": true, "license": "MIT", "optional": true, "os": [ @@ -5931,9 +6104,9 @@ ] }, "node_modules/@rollup/rollup-linux-arm64-musl": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.50.0.tgz", - "integrity": "sha512-EtBDIZuDtVg75xIPIK1l5vCXNNCIRM0OBPUG+tbApDuJAy9mKago6QxX+tfMzbCI6tXEhMuZuN1+CU8iDW+0UQ==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.55.1.tgz", + "integrity": "sha512-puS1MEgWX5GsHSoiAsF0TYrpomdvkaXm0CofIMG5uVkP6IBV+ZO9xhC5YEN49nsgYo1DuuMquF9+7EDBVYu4uA==", "cpu": [ "arm64" ], @@ -5944,10 +6117,24 @@ "linux" ] }, - "node_modules/@rollup/rollup-linux-loongarch64-gnu": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.50.0.tgz", - "integrity": "sha512-BGYSwJdMP0hT5CCmljuSNx7+k+0upweM2M4YGfFBjnFSZMHOLYR0gEEj/dxyYJ6Zc6AiSeaBY8dWOa11GF/ppQ==", + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.55.1.tgz", + "integrity": "sha512-r3Wv40in+lTsULSb6nnoudVbARdOwb2u5fpeoOAZjFLznp6tDU8kd+GTHmJoqZ9lt6/Sys33KdIHUaQihFcu7g==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.55.1.tgz", + "integrity": "sha512-MR8c0+UxAlB22Fq4R+aQSPBayvYa3+9DrwG/i1TKQXFYEaoW3B5b/rkSRIypcZDdWjWnpcvxbNaAJDcSbJU3Lw==", "cpu": [ "loong64" ], @@ -5959,9 +6146,23 @@ ] }, "node_modules/@rollup/rollup-linux-ppc64-gnu": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.50.0.tgz", - "integrity": "sha512-I1gSMzkVe1KzAxKAroCJL30hA4DqSi+wGc5gviD0y3IL/VkvcnAqwBf4RHXHyvH66YVHxpKO8ojrgc4SrWAnLg==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.55.1.tgz", + "integrity": "sha512-3KhoECe1BRlSYpMTeVrD4sh2Pw2xgt4jzNSZIIPLFEsnQn9gAnZagW9+VqDqAHgm1Xc77LzJOo2LdigS5qZ+gw==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.55.1.tgz", + "integrity": "sha512-ziR1OuZx0vdYZZ30vueNZTg73alF59DicYrPViG0NEgDVN8/Jl87zkAPu4u6VjZST2llgEUjaiNl9JM6HH1Vdw==", "cpu": [ "ppc64" ], @@ -5973,9 +6174,9 @@ ] }, "node_modules/@rollup/rollup-linux-riscv64-gnu": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.50.0.tgz", - "integrity": "sha512-bSbWlY3jZo7molh4tc5dKfeSxkqnf48UsLqYbUhnkdnfgZjgufLS/NTA8PcP/dnvct5CCdNkABJ56CbclMRYCA==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.55.1.tgz", + "integrity": "sha512-uW0Y12ih2XJRERZ4jAfKamTyIHVMPQnTZcQjme2HMVDAHY4amf5u414OqNYC+x+LzRdRcnIG1YodLrrtA8xsxw==", "cpu": [ "riscv64" ], @@ -5987,9 +6188,9 @@ ] }, "node_modules/@rollup/rollup-linux-riscv64-musl": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.50.0.tgz", - "integrity": "sha512-LSXSGumSURzEQLT2e4sFqFOv3LWZsEF8FK7AAv9zHZNDdMnUPYH3t8ZlaeYYZyTXnsob3htwTKeWtBIkPV27iQ==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.55.1.tgz", + "integrity": "sha512-u9yZ0jUkOED1BFrqu3BwMQoixvGHGZ+JhJNkNKY/hyoEgOwlqKb62qu+7UjbPSHYjiVy8kKJHvXKv5coH4wDeg==", "cpu": [ "riscv64" ], @@ -6001,9 +6202,9 @@ ] }, "node_modules/@rollup/rollup-linux-s390x-gnu": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.50.0.tgz", - "integrity": "sha512-CxRKyakfDrsLXiCyucVfVWVoaPA4oFSpPpDwlMcDFQvrv3XY6KEzMtMZrA+e/goC8xxp2WSOxHQubP8fPmmjOQ==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.55.1.tgz", + "integrity": "sha512-/0PenBCmqM4ZUd0190j7J0UsQ/1nsi735iPRakO8iPciE7BQ495Y6msPzaOmvx0/pn+eJVVlZrNrSh4WSYLxNg==", "cpu": [ "s390x" ], @@ -6015,13 +6216,12 @@ ] }, "node_modules/@rollup/rollup-linux-x64-gnu": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.50.0.tgz", - "integrity": "sha512-8PrJJA7/VU8ToHVEPu14FzuSAqVKyo5gg/J8xUerMbyNkWkO9j2ExBho/68RnJsMGNJq4zH114iAttgm7BZVkA==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.55.1.tgz", + "integrity": "sha512-a8G4wiQxQG2BAvo+gU6XrReRRqj+pLS2NGXKm8io19goR+K8lw269eTrPkSdDTALwMmJp4th2Uh0D8J9bEV1vg==", "cpu": [ "x64" ], - "dev": true, "license": "MIT", "optional": true, "os": [ @@ -6029,9 +6229,9 @@ ] }, "node_modules/@rollup/rollup-linux-x64-musl": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.50.0.tgz", - "integrity": "sha512-SkE6YQp+CzpyOrbw7Oc4MgXFvTw2UIBElvAvLCo230pyxOLmYwRPwZ/L5lBe/VW/qT1ZgND9wJfOsdy0XptRvw==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.55.1.tgz", + "integrity": "sha512-bD+zjpFrMpP/hqkfEcnjXWHMw5BIghGisOKPj+2NaNDuVT+8Ds4mPf3XcPHuat1tz89WRL+1wbcxKY3WSbiT7w==", "cpu": [ "x64" ], @@ -6042,10 +6242,24 @@ "linux" ] }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.55.1.tgz", + "integrity": "sha512-eLXw0dOiqE4QmvikfQ6yjgkg/xDM+MdU9YJuP4ySTibXU0oAvnEWXt7UDJmD4UkYialMfOGFPJnIHSe/kdzPxg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, "node_modules/@rollup/rollup-openharmony-arm64": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.50.0.tgz", - "integrity": "sha512-PZkNLPfvXeIOgJWA804zjSFH7fARBBCpCXxgkGDRjjAhRLOR8o0IGS01ykh5GYfod4c2yiiREuDM8iZ+pVsT+Q==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.55.1.tgz", + "integrity": "sha512-xzm44KgEP11te3S2HCSyYf5zIzWmx3n8HDCc7EE59+lTcswEWNpvMLfd9uJvVX8LCg9QWG67Xt75AuHn4vgsXw==", "cpu": [ "arm64" ], @@ -6057,9 +6271,9 @@ ] }, "node_modules/@rollup/rollup-win32-arm64-msvc": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.50.0.tgz", - "integrity": "sha512-q7cIIdFvWQoaCbLDUyUc8YfR3Jh2xx3unO8Dn6/TTogKjfwrax9SyfmGGK6cQhKtjePI7jRfd7iRYcxYs93esg==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.55.1.tgz", + "integrity": "sha512-yR6Bl3tMC/gBok5cz/Qi0xYnVbIxGx5Fcf/ca0eB6/6JwOY+SRUcJfI0OpeTpPls7f194as62thCt/2BjxYN8g==", "cpu": [ "arm64" ], @@ -6071,9 +6285,9 @@ ] }, "node_modules/@rollup/rollup-win32-ia32-msvc": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.50.0.tgz", - "integrity": "sha512-XzNOVg/YnDOmFdDKcxxK410PrcbcqZkBmz+0FicpW5jtjKQxcW1BZJEQOF0NJa6JO7CZhett8GEtRN/wYLYJuw==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.55.1.tgz", + "integrity": "sha512-3fZBidchE0eY0oFZBnekYCfg+5wAB0mbpCBuofh5mZuzIU/4jIVkbESmd2dOsFNS78b53CYv3OAtwqkZZmU5nA==", "cpu": [ "ia32" ], @@ -6084,10 +6298,10 @@ "win32" ] }, - "node_modules/@rollup/rollup-win32-x64-msvc": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.50.0.tgz", - "integrity": "sha512-xMmiWRR8sp72Zqwjgtf3QbZfF1wdh8X2ABu3EaozvZcyHJeU0r+XAnXdKgs4cCAp6ORoYoCygipYP1mjmbjrsg==", + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.55.1.tgz", + "integrity": "sha512-xGGY5pXj69IxKb4yv/POoocPy/qmEGhimy/FoTpTSVju3FYXUQQMFCaZZXJVidsmGxRioZAwpThl/4zX41gRKg==", "cpu": [ "x64" ], @@ -6098,6 +6312,19 @@ "win32" ] }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.55.1.tgz", + "integrity": "sha512-SPEpaL6DX4rmcXtnhdrQYgzQ5W2uW3SCJch88lB2zImhJRhIIK44fkUrgIV/Q8yUNfw5oyZ5vkeQsZLhCb06lw==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, "node_modules/@types/aws-lambda": { "version": "8.10.147", "resolved": "https://registry.npmjs.org/@types/aws-lambda/-/aws-lambda-8.10.147.tgz", @@ -6114,13 +6341,14 @@ } }, "node_modules/@types/chai": { - "version": "5.2.2", - "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.2.tgz", - "integrity": "sha512-8kB30R7Hwqf40JPiKhVzodJs2Qc1ZJ5zuT3uzw5Hq/dhNCl3G3l83jfpdI1e20BP348+fV7VIL/+FxaXkqBmWg==", + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz", + "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", "dev": true, "license": "MIT", "dependencies": { - "@types/deep-eql": "*" + "@types/deep-eql": "*", + "assertion-error": "^2.0.1" } }, "node_modules/@types/connect": { @@ -6150,12 +6378,13 @@ "version": "1.1.5", "resolved": "https://registry.npmjs.org/@types/fined/-/fined-1.1.5.tgz", "integrity": "sha512-2N93vadEGDFhASTIRbizbl4bNqpMOId5zZfj6hHqYZfEzEfO9onnU4Im8xvzo8uudySDveDHBOOSlTWf38ErfQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/inquirer": { - "version": "9.0.8", - "resolved": "https://registry.npmjs.org/@types/inquirer/-/inquirer-9.0.8.tgz", - "integrity": "sha512-CgPD5kFGWsb8HJ5K7rfWlifao87m4ph8uioU7OTncJevmE/VLIqAAjfQtko578JZg7/f69K4FgqYym3gNr7DeA==", + "version": "9.0.9", + "resolved": "https://registry.npmjs.org/@types/inquirer/-/inquirer-9.0.9.tgz", + "integrity": "sha512-/mWx5136gts2Z2e5izdoRCo46lPp5TMs9R15GTSsgg/XnZyxDWVqoVU3R9lWnccKpqwsJLvRoxbCjoJtZB7DSw==", "dev": true, "license": "MIT", "dependencies": { @@ -6167,13 +6396,15 @@ "version": "7.0.15", "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/liftoff": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/@types/liftoff/-/liftoff-4.0.3.tgz", "integrity": "sha512-UgbL2kR5pLrWICvr8+fuSg0u43LY250q7ZMkC+XKC3E+rs/YBDEnQIzsnhU5dYsLlwMi3R75UvCL87pObP1sxw==", "dev": true, + "license": "MIT", "dependencies": { "@types/fined": "*", "@types/node": "*" @@ -6198,9 +6429,10 @@ } }, "node_modules/@types/node": { - "version": "22.15.23", - "resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.23.tgz", - "integrity": "sha512-7Ec1zaFPF4RJ0eXu1YT/xgiebqwqoJz8rYPDi/O2BcZ++Wpt0Kq9cl0eg6NN6bYbPnR67ZLo7St5Q3UK0SnARw==", + "version": "22.19.3", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.3.tgz", + "integrity": "sha512-1N9SBnWYOJTrNZCdh/yJE+t910Y128BoyY+zBLWhL3r0TYzlTmFdXrPwHL9DyFZmlEXNQQolTZh3KHV31QDhyA==", + "license": "MIT", "dependencies": { "undici-types": "~6.21.0" } @@ -6225,6 +6457,13 @@ "@types/pg": "*" } }, + "node_modules/@types/picomatch": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/picomatch/-/picomatch-4.0.2.tgz", + "integrity": "sha512-qHHxQ+P9PysNEGbALT8f8YOSHW0KJu6l2xU8DYY0fu/EmGxXdVnuTLvFUvBgPJMSqXq29SYHveejeAha+4AYgA==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/shimmer": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/@types/shimmer/-/shimmer-1.2.0.tgz", @@ -6251,21 +6490,20 @@ } }, "node_modules/@typescript-eslint/eslint-plugin": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.42.0.tgz", - "integrity": "sha512-Aq2dPqsQkxHOLfb2OPv43RnIvfj05nw8v/6n3B2NABIPpHnjQnaLo9QGMTvml+tv4korl/Cjfrb/BYhoL8UUTQ==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.52.0.tgz", + "integrity": "sha512-okqtOgqu2qmZJ5iN4TWlgfF171dZmx2FzdOv2K/ixL2LZWDStL8+JgQerI2sa8eAEfoydG9+0V96m7V+P8yE1Q==", "dev": true, "license": "MIT", "dependencies": { - "@eslint-community/regexpp": "^4.10.0", - "@typescript-eslint/scope-manager": "8.42.0", - "@typescript-eslint/type-utils": "8.42.0", - "@typescript-eslint/utils": "8.42.0", - "@typescript-eslint/visitor-keys": "8.42.0", - "graphemer": "^1.4.0", - "ignore": "^7.0.0", + "@eslint-community/regexpp": "^4.12.2", + "@typescript-eslint/scope-manager": "8.52.0", + "@typescript-eslint/type-utils": "8.52.0", + "@typescript-eslint/utils": "8.52.0", + "@typescript-eslint/visitor-keys": "8.52.0", + "ignore": "^7.0.5", "natural-compare": "^1.4.0", - "ts-api-utils": "^2.1.0" + "ts-api-utils": "^2.4.0" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -6275,23 +6513,23 @@ "url": "https://opencollective.com/typescript-eslint" }, "peerDependencies": { - "@typescript-eslint/parser": "^8.42.0", + "@typescript-eslint/parser": "^8.52.0", "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "node_modules/@typescript-eslint/parser": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.42.0.tgz", - "integrity": "sha512-r1XG74QgShUgXph1BYseJ+KZd17bKQib/yF3SR+demvytiRXrwd12Blnz5eYGm8tXaeRdd4x88MlfwldHoudGg==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.52.0.tgz", + "integrity": "sha512-iIACsx8pxRnguSYhHiMn2PvhvfpopO9FXHyn1mG5txZIsAaB6F0KwbFnUQN3KCiG3Jcuad/Cao2FAs1Wp7vAyg==", "dev": true, "license": "MIT", "dependencies": { - "@typescript-eslint/scope-manager": "8.42.0", - "@typescript-eslint/types": "8.42.0", - "@typescript-eslint/typescript-estree": "8.42.0", - "@typescript-eslint/visitor-keys": "8.42.0", - "debug": "^4.3.4" + "@typescript-eslint/scope-manager": "8.52.0", + "@typescript-eslint/types": "8.52.0", + "@typescript-eslint/typescript-estree": "8.52.0", + "@typescript-eslint/visitor-keys": "8.52.0", + "debug": "^4.4.3" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -6306,15 +6544,15 @@ } }, "node_modules/@typescript-eslint/project-service": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.42.0.tgz", - "integrity": "sha512-vfVpLHAhbPjilrabtOSNcUDmBboQNrJUiNAGoImkZKnMjs2TIcWG33s4Ds0wY3/50aZmTMqJa6PiwkwezaAklg==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.52.0.tgz", + "integrity": "sha512-xD0MfdSdEmeFa3OmVqonHi+Cciab96ls1UhIF/qX/O/gPu5KXD0bY9lu33jj04fjzrXHcuvjBcBC+D3SNSadaw==", "dev": true, "license": "MIT", "dependencies": { - "@typescript-eslint/tsconfig-utils": "^8.42.0", - "@typescript-eslint/types": "^8.42.0", - "debug": "^4.3.4" + "@typescript-eslint/tsconfig-utils": "^8.52.0", + "@typescript-eslint/types": "^8.52.0", + "debug": "^4.4.3" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -6328,14 +6566,14 @@ } }, "node_modules/@typescript-eslint/scope-manager": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.42.0.tgz", - "integrity": "sha512-51+x9o78NBAVgQzOPd17DkNTnIzJ8T/O2dmMBLoK9qbY0Gm52XJcdJcCl18ExBMiHo6jPMErUQWUv5RLE51zJw==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.52.0.tgz", + "integrity": "sha512-ixxqmmCcc1Nf8S0mS0TkJ/3LKcC8mruYJPOU6Ia2F/zUUR4pApW7LzrpU3JmtePbRUTes9bEqRc1Gg4iyRnDzA==", "dev": true, "license": "MIT", "dependencies": { - "@typescript-eslint/types": "8.42.0", - "@typescript-eslint/visitor-keys": "8.42.0" + "@typescript-eslint/types": "8.52.0", + "@typescript-eslint/visitor-keys": "8.52.0" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -6346,9 +6584,9 @@ } }, "node_modules/@typescript-eslint/tsconfig-utils": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.42.0.tgz", - "integrity": "sha512-kHeFUOdwAJfUmYKjR3CLgZSglGHjbNTi1H8sTYRYV2xX6eNz4RyJ2LIgsDLKf8Yi0/GL1WZAC/DgZBeBft8QAQ==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.52.0.tgz", + "integrity": "sha512-jl+8fzr/SdzdxWJznq5nvoI7qn2tNYV/ZBAEcaFMVXf+K6jmXvAFrgo/+5rxgnL152f//pDEAYAhhBAZGrVfwg==", "dev": true, "license": "MIT", "engines": { @@ -6363,17 +6601,17 @@ } }, "node_modules/@typescript-eslint/type-utils": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.42.0.tgz", - "integrity": "sha512-9KChw92sbPTYVFw3JLRH1ockhyR3zqqn9lQXol3/YbI6jVxzWoGcT3AsAW0mu1MY0gYtsXnUGV/AKpkAj5tVlQ==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.52.0.tgz", + "integrity": "sha512-JD3wKBRWglYRQkAtsyGz1AewDu3mTc7NtRjR/ceTyGoPqmdS5oCdx/oZMWD5Zuqmo6/MpsYs0wp6axNt88/2EQ==", "dev": true, "license": "MIT", "dependencies": { - "@typescript-eslint/types": "8.42.0", - "@typescript-eslint/typescript-estree": "8.42.0", - "@typescript-eslint/utils": "8.42.0", - "debug": "^4.3.4", - "ts-api-utils": "^2.1.0" + "@typescript-eslint/types": "8.52.0", + "@typescript-eslint/typescript-estree": "8.52.0", + "@typescript-eslint/utils": "8.52.0", + "debug": "^4.4.3", + "ts-api-utils": "^2.4.0" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -6388,9 +6626,9 @@ } }, "node_modules/@typescript-eslint/types": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.42.0.tgz", - "integrity": "sha512-LdtAWMiFmbRLNP7JNeY0SqEtJvGMYSzfiWBSmx+VSZ1CH+1zyl8Mmw1TT39OrtsRvIYShjJWzTDMPWZJCpwBlw==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.52.0.tgz", + "integrity": "sha512-LWQV1V4q9V4cT4H5JCIx3481iIFxH1UkVk+ZkGGAV1ZGcjGI9IoFOfg3O6ywz8QqCDEp7Inlg6kovMofsNRaGg==", "dev": true, "license": "MIT", "engines": { @@ -6402,22 +6640,21 @@ } }, "node_modules/@typescript-eslint/typescript-estree": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.42.0.tgz", - "integrity": "sha512-ku/uYtT4QXY8sl9EDJETD27o3Ewdi72hcXg1ah/kkUgBvAYHLwj2ofswFFNXS+FL5G+AGkxBtvGt8pFBHKlHsQ==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.52.0.tgz", + "integrity": "sha512-XP3LClsCc0FsTK5/frGjolyADTh3QmsLp6nKd476xNI9CsSsLnmn4f0jrzNoAulmxlmNIpeXuHYeEQv61Q6qeQ==", "dev": true, "license": "MIT", "dependencies": { - "@typescript-eslint/project-service": "8.42.0", - "@typescript-eslint/tsconfig-utils": "8.42.0", - "@typescript-eslint/types": "8.42.0", - "@typescript-eslint/visitor-keys": "8.42.0", - "debug": "^4.3.4", - "fast-glob": "^3.3.2", - "is-glob": "^4.0.3", - "minimatch": "^9.0.4", - "semver": "^7.6.0", - "ts-api-utils": "^2.1.0" + "@typescript-eslint/project-service": "8.52.0", + "@typescript-eslint/tsconfig-utils": "8.52.0", + "@typescript-eslint/types": "8.52.0", + "@typescript-eslint/visitor-keys": "8.52.0", + "debug": "^4.4.3", + "minimatch": "^9.0.5", + "semver": "^7.7.3", + "tinyglobby": "^0.2.15", + "ts-api-utils": "^2.4.0" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -6431,16 +6668,16 @@ } }, "node_modules/@typescript-eslint/utils": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.42.0.tgz", - "integrity": "sha512-JnIzu7H3RH5BrKC4NoZqRfmjqCIS1u3hGZltDYJgkVdqAezl4L9d1ZLw+36huCujtSBSAirGINF/S4UxOcR+/g==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.52.0.tgz", + "integrity": "sha512-wYndVMWkweqHpEpwPhwqE2lnD2DxC6WVLupU/DOt/0/v+/+iQbbzO3jOHjmBMnhu0DgLULvOaU4h4pwHYi2oRQ==", "dev": true, "license": "MIT", "dependencies": { - "@eslint-community/eslint-utils": "^4.7.0", - "@typescript-eslint/scope-manager": "8.42.0", - "@typescript-eslint/types": "8.42.0", - "@typescript-eslint/typescript-estree": "8.42.0" + "@eslint-community/eslint-utils": "^4.9.1", + "@typescript-eslint/scope-manager": "8.52.0", + "@typescript-eslint/types": "8.52.0", + "@typescript-eslint/typescript-estree": "8.52.0" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -6455,13 +6692,13 @@ } }, "node_modules/@typescript-eslint/visitor-keys": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.42.0.tgz", - "integrity": "sha512-3WbiuzoEowaEn8RSnhJBrxSwX8ULYE9CXaPepS2C2W3NSA5NNIvBaslpBSBElPq0UGr0xVJlXFWOAKIkyylydQ==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.52.0.tgz", + "integrity": "sha512-ink3/Zofus34nmBsPjow63FP5M7IGff0RKAgqR6+CFpdk22M7aLwC9gOcLGYqr7MczLPzZVERW9hRog3O4n1sQ==", "dev": true, "license": "MIT", "dependencies": { - "@typescript-eslint/types": "8.42.0", + "@typescript-eslint/types": "8.52.0", "eslint-visitor-keys": "^4.2.1" }, "engines": { @@ -6510,97 +6747,6 @@ "vitest": "3.2.4" } }, - "node_modules/@vitest/coverage-istanbul/node_modules/glob": { - "version": "10.4.5", - "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz", - "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==", - "dev": true, - "license": "ISC", - "dependencies": { - "foreground-child": "^3.1.0", - "jackspeak": "^3.1.2", - "minimatch": "^9.0.4", - "minipass": "^7.1.2", - "package-json-from-dist": "^1.0.0", - "path-scurry": "^1.11.1" - }, - "bin": { - "glob": "dist/esm/bin.mjs" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "node_modules/@vitest/coverage-istanbul/node_modules/istanbul-lib-source-maps": { - "version": "5.0.6", - "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-5.0.6.tgz", - "integrity": "sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==", - "dev": true, - "license": "BSD-3-Clause", - "dependencies": { - "@jridgewell/trace-mapping": "^0.3.23", - "debug": "^4.1.1", - "istanbul-lib-coverage": "^3.0.0" - }, - "engines": { - "node": ">=10" - } - }, - "node_modules/@vitest/coverage-istanbul/node_modules/jackspeak": { - "version": "3.4.3", - "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", - "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "@isaacs/cliui": "^8.0.2" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - }, - "optionalDependencies": { - "@pkgjs/parseargs": "^0.11.0" - } - }, - "node_modules/@vitest/coverage-istanbul/node_modules/lru-cache": { - "version": "10.4.3", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz", - "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==", - "dev": true, - "license": "ISC" - }, - "node_modules/@vitest/coverage-istanbul/node_modules/path-scurry": { - "version": "1.11.1", - "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", - "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "lru-cache": "^10.2.0", - "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" - }, - "engines": { - "node": ">=16 || 14 >=14.18" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "node_modules/@vitest/coverage-istanbul/node_modules/test-exclude": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-7.0.1.tgz", - "integrity": "sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==", - "dev": true, - "license": "ISC", - "dependencies": { - "@istanbuljs/schema": "^0.1.2", - "glob": "^10.4.1", - "minimatch": "^9.0.4" - }, - "engines": { - "node": ">=18" - } - }, "node_modules/@vitest/expect": { "version": "3.2.4", "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.4.tgz", @@ -6727,6 +6873,7 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz", "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==", + "license": "MIT", "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" @@ -6736,9 +6883,10 @@ } }, "node_modules/acorn": { - "version": "8.14.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz", - "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==", + "version": "8.15.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", + "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", + "license": "MIT", "bin": { "acorn": "bin/acorn" }, @@ -6760,6 +6908,7 @@ "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", "dev": true, + "license": "MIT", "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } @@ -6773,33 +6922,16 @@ "node": ">= 14" } }, - "node_modules/aggregate-error": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-4.0.1.tgz", - "integrity": "sha512-0poP0T7el6Vq3rstR8Mn4V/IQrpBLO6POkUSrN7RhyY+GF/InCFShQzsQ39T25gkHhLgSLByyAz+Kjb+c2L98w==", - "dev": true, + "node_modules/ajv": { + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz", + "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==", "license": "MIT", "dependencies": { - "clean-stack": "^4.0.0", - "indent-string": "^5.0.0" - }, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/ajv": { - "version": "6.12.6", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", - "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", - "dev": true, - "dependencies": { - "fast-deep-equal": "^3.1.1", - "fast-json-stable-stringify": "^2.0.0", - "json-schema-traverse": "^0.4.1", - "uri-js": "^4.2.2" + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" }, "funding": { "type": "github", @@ -6823,89 +6955,61 @@ } } }, - "node_modules/ajv-formats/node_modules/ajv": { - "version": "8.17.1", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz", - "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==", - "license": "MIT", - "dependencies": { - "fast-deep-equal": "^3.1.3", - "fast-uri": "^3.0.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/epoberezkin" - } - }, - "node_modules/ajv-formats/node_modules/json-schema-traverse": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", - "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", - "license": "MIT" - }, "node_modules/ansi-escapes": { - "version": "4.3.2", - "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", - "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.2.0.tgz", + "integrity": "sha512-g6LhBsl+GBPRWGWsBtutpzBYuIIdBkLEvad5C/va/74Db018+5TZiyA26cZJAr3Rft5lprVqOIPxf5Vid6tqAw==", "dev": true, + "license": "MIT", "dependencies": { - "type-fest": "^0.21.3" + "environment": "^1.0.0" }, "engines": { - "node": ">=8" + "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/ansi-regex": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", + "dev": true, + "license": "MIT", "engines": { - "node": ">=8" + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" } }, "node_modules/ansi-styles": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", - "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", - "dependencies": { - "color-convert": "^2.0.1" - }, + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz", + "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==", + "dev": true, + "license": "MIT", "engines": { - "node": ">=8" + "node": ">=12" }, "funding": { "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, - "node_modules/anymatch": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", - "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", - "dev": true, - "dependencies": { - "normalize-path": "^3.0.0", - "picomatch": "^2.0.4" - }, - "engines": { - "node": ">= 8" - } - }, "node_modules/argparse": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", - "dev": true + "dev": true, + "license": "Python-2.0" }, "node_modules/array-each": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/array-each/-/array-each-1.0.1.tgz", "integrity": "sha512-zHjL5SZa68hkKHBFBK6DJCTtr9sfTCPCaph/L7tMSLcTFgy+zX7E+6q5UArbtOtMBCtxdICpfTCspRse+ywyXA==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -6915,6 +7019,7 @@ "resolved": "https://registry.npmjs.org/array-slice/-/array-slice-1.1.0.tgz", "integrity": "sha512-B1qMD3RBP7O8o0H2KbrXDyB0IccejMF15+87Lvlor12ONPRHP6gTjXMNkt/d3ZuOGbAe66hFmaCfECI24Ufp6w==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -6940,7 +7045,8 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/base64-js": { "version": "1.5.1", @@ -6963,6 +7069,16 @@ ], "license": "MIT" }, + "node_modules/baseline-browser-mapping": { + "version": "2.9.12", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.12.tgz", + "integrity": "sha512-Mij6Lij93pTAIsSYy5cyBQ975Qh9uLEc5rwGTpomiZeXZL9yIS6uORJakb3ScHgfs0serMMfIbXzokPMuEiRyw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.js" + } + }, "node_modules/bignumber.js": { "version": "9.3.1", "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.1.tgz", @@ -6972,19 +7088,6 @@ "node": "*" } }, - "node_modules/binary-extensions": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", - "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=8" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/bl": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz", @@ -6998,22 +7101,27 @@ } }, "node_modules/body-parser": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.0.tgz", - "integrity": "sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==", + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.2.tgz", + "integrity": "sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==", + "license": "MIT", "dependencies": { "bytes": "^3.1.2", "content-type": "^1.0.5", - "debug": "^4.4.0", + "debug": "^4.4.3", "http-errors": "^2.0.0", - "iconv-lite": "^0.6.3", + "iconv-lite": "^0.7.0", "on-finished": "^2.4.1", - "qs": "^6.14.0", - "raw-body": "^3.0.0", - "type-is": "^2.0.0" + "qs": "^6.14.1", + "raw-body": "^3.0.1", + "type-is": "^2.0.1" }, "engines": { "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/brace-expansion": { @@ -7031,6 +7139,7 @@ "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", "dev": true, + "license": "MIT", "dependencies": { "fill-range": "^7.1.1" }, @@ -7039,9 +7148,9 @@ } }, "node_modules/browserslist": { - "version": "4.24.5", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.5.tgz", - "integrity": "sha512-FDToo4Wo82hIdgc1CQ+NQD0hEhmpPjrZ3hiUgwgOG6IuTdlpr8jdjyG24P6cNP1yJpTLzS5OcGgSw0xmDU1/Tw==", + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz", + "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==", "dev": true, "funding": [ { @@ -7057,11 +7166,13 @@ "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "dependencies": { - "caniuse-lite": "^1.0.30001716", - "electron-to-chromium": "^1.5.149", - "node-releases": "^2.0.19", - "update-browserslist-db": "^1.1.3" + "baseline-browser-mapping": "^2.9.0", + "caniuse-lite": "^1.0.30001759", + "electron-to-chromium": "^1.5.263", + "node-releases": "^2.0.27", + "update-browserslist-db": "^1.2.0" }, "bin": { "browserslist": "cli.js" @@ -7099,6 +7210,7 @@ "version": "3.1.2", "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", "engines": { "node": ">= 0.8" } @@ -7136,6 +7248,7 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "license": "MIT", "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" @@ -7148,6 +7261,7 @@ "version": "1.0.4", "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "license": "MIT", "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" @@ -7164,25 +7278,15 @@ "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=6" } }, - "node_modules/camel-case": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz", - "integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==", - "dev": true, - "license": "MIT", - "dependencies": { - "pascal-case": "^3.1.2", - "tslib": "^2.0.3" - } - }, "node_modules/caniuse-lite": { - "version": "1.0.30001718", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001718.tgz", - "integrity": "sha512-AflseV1ahcSunK53NfEs9gFWgOEmzr0f+kaMFA4xiLZlr9Hzt7HxcSpIFcnNCUkz6R6dWKa54rUz3HUmI3nVcw==", + "version": "1.0.30001762", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001762.tgz", + "integrity": "sha512-PxZwGNvH7Ak8WX5iXzoK1KPZttBXNPuaOvI2ZYU7NrlM+d9Ov+TUvlLOBNGzVXAntMSMMlJPd+jY6ovrVjSmUw==", "dev": true, "funding": [ { @@ -7197,19 +7301,8 @@ "type": "github", "url": "https://github.com/sponsors/ai" } - ] - }, - "node_modules/capital-case": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/capital-case/-/capital-case-1.0.4.tgz", - "integrity": "sha512-ds37W8CytHgwnhGGTi88pcPyR15qoNkOpYwmMMfnWqqWgESapLqvDx6huFjQ5vqWSn2Z06173XNA7LtMOeUh1A==", - "dev": true, - "license": "MIT", - "dependencies": { - "no-case": "^3.0.4", - "tslib": "^2.0.3", - "upper-case-first": "^2.0.2" - } + ], + "license": "CC-BY-4.0" }, "node_modules/chai": { "version": "5.3.3", @@ -7229,16 +7322,13 @@ } }, "node_modules/chalk": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", - "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "version": "5.6.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz", + "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==", "dev": true, - "dependencies": { - "ansi-styles": "^4.1.0", - "supports-color": "^7.1.0" - }, + "license": "MIT", "engines": { - "node": ">=10" + "node": "^12.17.0 || ^14.13 || >=16.0.0" }, "funding": { "url": "https://github.com/chalk/chalk?sponsor=1" @@ -7260,51 +7350,24 @@ "url": "https://github.com/chalk/chalk-template?sponsor=1" } }, - "node_modules/chalk-template/node_modules/chalk": { - "version": "5.6.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz", - "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==", - "dev": true, - "license": "MIT", - "engines": { - "node": "^12.17.0 || ^14.13 || >=16.0.0" - }, - "funding": { - "url": "https://github.com/chalk/chalk?sponsor=1" - } - }, "node_modules/change-case": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/change-case/-/change-case-4.1.2.tgz", - "integrity": "sha512-bSxY2ws9OtviILG1EiY5K7NNxkqg/JnRnFxLtKQ96JaviiIxi7djMrSd0ECT9AC+lttClmYwKw53BWpOMblo7A==", + "version": "5.4.4", + "resolved": "https://registry.npmjs.org/change-case/-/change-case-5.4.4.tgz", + "integrity": "sha512-HRQyTk2/YPEkt9TnUPbOpr64Uw3KOicFWPVBb+xiHvd6eBx/qPr9xqfBFDT8P2vWsvvz4jbEkfDe71W3VyNu2w==", "dev": true, - "license": "MIT", - "dependencies": { - "camel-case": "^4.1.2", - "capital-case": "^1.0.4", - "constant-case": "^3.0.4", - "dot-case": "^3.0.4", - "header-case": "^2.0.4", - "no-case": "^3.0.4", - "param-case": "^3.0.4", - "pascal-case": "^3.1.2", - "path-case": "^3.0.4", - "sentence-case": "^3.0.4", - "snake-case": "^3.0.4", - "tslib": "^2.0.3" - } + "license": "MIT" }, "node_modules/chardet": { - "version": "0.7.0", - "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz", - "integrity": "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/chardet/-/chardet-2.1.1.tgz", + "integrity": "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==", "dev": true, "license": "MIT" }, "node_modules/check-error": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz", - "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==", + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz", + "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==", "dev": true, "license": "MIT", "engines": { @@ -7312,41 +7375,19 @@ } }, "node_modules/chokidar": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", - "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz", + "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==", "dev": true, "license": "MIT", "dependencies": { - "anymatch": "~3.1.2", - "braces": "~3.0.2", - "glob-parent": "~5.1.2", - "is-binary-path": "~2.1.0", - "is-glob": "~4.0.1", - "normalize-path": "~3.0.0", - "readdirp": "~3.6.0" + "readdirp": "^4.0.1" }, "engines": { - "node": ">= 8.10.0" + "node": ">= 14.16.0" }, "funding": { "url": "https://paulmillr.com/funding/" - }, - "optionalDependencies": { - "fsevents": "~2.3.2" - } - }, - "node_modules/chokidar/node_modules/glob-parent": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", - "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", - "dev": true, - "license": "ISC", - "dependencies": { - "is-glob": "^4.0.1" - }, - "engines": { - "node": ">= 6" } }, "node_modules/ci-info": { @@ -7371,35 +7412,6 @@ "integrity": "sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==", "license": "MIT" }, - "node_modules/clean-stack": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-4.2.0.tgz", - "integrity": "sha512-LYv6XPxoyODi36Dp976riBtSY27VmFo+MKqEU9QCCWyTrdEPDog+RWA7xQWHi6Vbp61j5c4cdzzX1NidnwtUWg==", - "dev": true, - "license": "MIT", - "dependencies": { - "escape-string-regexp": "5.0.0" - }, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/clean-stack/node_modules/escape-string-regexp": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz", - "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/clear-module": { "version": "4.1.2", "resolved": "https://registry.npmjs.org/clear-module/-/clear-module-4.1.2.tgz", @@ -7417,34 +7429,12 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/clear-module/node_modules/parent-module": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-2.0.0.tgz", - "integrity": "sha512-uo0Z9JJeWzv8BG+tRcapBKNJ0dro9cLyczGzulS6EfeyAdeC9sbojtW6XwvYxJkEne9En+J2XEl4zyglVeIwFg==", - "dev": true, - "license": "MIT", - "dependencies": { - "callsites": "^3.1.0" - }, - "engines": { - "node": ">=8" - } - }, - "node_modules/clear-module/node_modules/resolve-from": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", - "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=8" - } - }, "node_modules/cli-cursor": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz", "integrity": "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==", "dev": true, + "license": "MIT", "dependencies": { "restore-cursor": "^5.0.0" }, @@ -7469,16 +7459,17 @@ } }, "node_modules/cli-truncate": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-4.0.0.tgz", - "integrity": "sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-5.1.1.tgz", + "integrity": "sha512-SroPvNHxUnk+vIW/dOSfNqdy1sPEFkrTk6TUtqLCnBlo3N7TNYYkzzN7uSD6+jVjrdO4+p8nH7JzH6cIvUem6A==", "dev": true, + "license": "MIT", "dependencies": { - "slice-ansi": "^5.0.0", - "string-width": "^7.0.0" + "slice-ansi": "^7.1.0", + "string-width": "^8.0.0" }, "engines": { - "node": ">=18" + "node": ">=20" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" @@ -7508,11 +7499,29 @@ "node": ">=12" } }, - "node_modules/cliui/node_modules/emoji-regex": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "license": "MIT" + "node_modules/cliui/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/cliui/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } }, "node_modules/cliui/node_modules/is-fullwidth-code-point": { "version": "3.0.0", @@ -7537,6 +7546,18 @@ "node": ">=8" } }, + "node_modules/cliui/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/cliui/node_modules/wrap-ansi": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", @@ -7568,6 +7589,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "license": "MIT", "dependencies": { "color-name": "~1.1.4" }, @@ -7578,18 +7600,20 @@ "node_modules/color-name": { "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", - "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==" + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "license": "MIT" }, "node_modules/colorette": { "version": "2.0.20", "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz", "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/commander": { - "version": "14.0.0", - "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.0.tgz", - "integrity": "sha512-2uM9rYjPvyq39NwLRqaiLtWHyDC1FvryJDa2ATTVims5YAS4PupsEQsDvP14FqhFr0P49CYDugi59xaxJlTXRA==", + "version": "14.0.2", + "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.2.tgz", + "integrity": "sha512-TywoWNNRbhoD0BXs1P3ZEScW8W5iKrnbithIl0YH+uCmBd0QpPOA8yc82DS3BIE5Ma6FnBVUsJ7wVUDz4dvOWQ==", "dev": true, "license": "MIT", "engines": { @@ -7597,9 +7621,9 @@ } }, "node_modules/comment-json": { - "version": "4.4.1", - "resolved": "https://registry.npmjs.org/comment-json/-/comment-json-4.4.1.tgz", - "integrity": "sha512-r1To31BQD5060QdkC+Iheai7gHwoSZobzunqkf2/kQ6xIAfJyrKNAFUwdKvkK7Qgu7pVTKQEa7ok7Ed3ycAJgg==", + "version": "4.5.1", + "resolved": "https://registry.npmjs.org/comment-json/-/comment-json-4.5.1.tgz", + "integrity": "sha512-taEtr3ozUmOB7it68Jll7s0Pwm+aoiHyXKrEC8SEodL4rNpdfDLqa7PfBlrgFoCNNdR8ImL+muti5IGvktJAAg==", "dev": true, "license": "MIT", "dependencies": { @@ -7615,35 +7639,27 @@ "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", - "dev": true - }, - "node_modules/constant-case": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/constant-case/-/constant-case-3.0.4.tgz", - "integrity": "sha512-I2hSBi7Vvs7BEuJDr5dDHfzb/Ruj3FyvFyh7KLilAjNQw3Be+xgqUBA2W6scVEcL0hL1dwPRtIqEPVUCKkSsyQ==", "dev": true, - "license": "MIT", - "dependencies": { - "no-case": "^3.0.4", - "tslib": "^2.0.3", - "upper-case": "^2.0.2" - } + "license": "MIT" }, "node_modules/content-disposition": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.0.tgz", - "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==", - "dependencies": { - "safe-buffer": "5.2.1" - }, + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.1.tgz", + "integrity": "sha512-oIXISMynqSqm241k6kcQ5UwttDILMK4BiurCfGEREw6+X9jkkpEe5T9FZaApyLGGOnFuyMWZpdolTXMtvEJ08Q==", + "license": "MIT", "engines": { - "node": ">= 0.6" + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/content-type": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "license": "MIT", "engines": { "node": ">= 0.6" } @@ -7652,12 +7668,14 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/cookie": { "version": "0.7.2", "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "license": "MIT", "engines": { "node": ">= 0.6" } @@ -7666,6 +7684,7 @@ "version": "1.2.2", "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz", "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==", + "license": "MIT", "engines": { "node": ">=6.6.0" } @@ -7694,6 +7713,7 @@ "version": "7.0.6", "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "license": "MIT", "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", @@ -7704,30 +7724,31 @@ } }, "node_modules/cspell": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/cspell/-/cspell-9.2.1.tgz", - "integrity": "sha512-PoKGKE9Tl87Sn/jwO4jvH7nTqe5Xrsz2DeJT5CkulY7SoL2fmsAqfbImQOFS2S0s36qD98t6VO+Ig2elEEcHew==", - "dev": true, - "license": "MIT", - "dependencies": { - "@cspell/cspell-json-reporter": "9.2.1", - "@cspell/cspell-pipe": "9.2.1", - "@cspell/cspell-types": "9.2.1", - "@cspell/dynamic-import": "9.2.1", - "@cspell/url": "9.2.1", - "chalk": "^5.6.0", - "chalk-template": "^1.1.0", - "commander": "^14.0.0", - "cspell-config-lib": "9.2.1", - "cspell-dictionary": "9.2.1", - "cspell-gitignore": "9.2.1", - "cspell-glob": "9.2.1", - "cspell-io": "9.2.1", - "cspell-lib": "9.2.1", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/cspell/-/cspell-9.4.0.tgz", + "integrity": "sha512-ZvXO+EY/G0/msu7jwRiVk0sXL/zB7DMJLBvjSUrK82uVbDoDxHwXxUuOz2UVnk2+J61//ldIZrjxVK8KMvaJlg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@cspell/cspell-json-reporter": "9.4.0", + "@cspell/cspell-pipe": "9.4.0", + "@cspell/cspell-types": "9.4.0", + "@cspell/dynamic-import": "9.4.0", + "@cspell/url": "9.4.0", + "ansi-regex": "^6.2.2", + "chalk": "^5.6.2", + "chalk-template": "^1.1.2", + "commander": "^14.0.2", + "cspell-config-lib": "9.4.0", + "cspell-dictionary": "9.4.0", + "cspell-gitignore": "9.4.0", + "cspell-glob": "9.4.0", + "cspell-io": "9.4.0", + "cspell-lib": "9.4.0", "fast-json-stable-stringify": "^2.1.0", "flatted": "^3.3.3", - "semver": "^7.7.2", - "tinyglobby": "^0.2.14" + "semver": "^7.7.3", + "tinyglobby": "^0.2.15" }, "bin": { "cspell": "bin.mjs", @@ -7741,47 +7762,47 @@ } }, "node_modules/cspell-config-lib": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/cspell-config-lib/-/cspell-config-lib-9.2.1.tgz", - "integrity": "sha512-qqhaWW+0Ilc7493lXAlXjziCyeEmQbmPMc1XSJw2EWZmzb+hDvLdFGHoX18QU67yzBtu5hgQsJDEDZKvVDTsRA==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/cspell-config-lib/-/cspell-config-lib-9.4.0.tgz", + "integrity": "sha512-CvQKSmK/DRIf3LpNx2sZth65pHW2AHngZqLkH3DTwnAPbiCAsE0XvCrVhvDfCNu/6uJIaa+NVHSs8GOf//DHBQ==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/cspell-types": "9.2.1", - "comment-json": "^4.2.5", - "smol-toml": "^1.4.2", - "yaml": "^2.8.1" + "@cspell/cspell-types": "9.4.0", + "comment-json": "^4.4.1", + "smol-toml": "^1.5.2", + "yaml": "^2.8.2" }, "engines": { "node": ">=20" } }, "node_modules/cspell-dictionary": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/cspell-dictionary/-/cspell-dictionary-9.2.1.tgz", - "integrity": "sha512-0hQVFySPsoJ0fONmDPwCWGSG6SGj4ERolWdx4t42fzg5zMs+VYGXpQW4BJneQ5Tfxy98Wx8kPhmh/9E8uYzLTw==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/cspell-dictionary/-/cspell-dictionary-9.4.0.tgz", + "integrity": "sha512-c2qscanRZChoHZFYI7KpvBMdy8i6wNwl2EflcNRrFiFOq67t9CgxLe54PafaqhrHGpBc8nElaZKciLvjj6Uscw==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/cspell-pipe": "9.2.1", - "@cspell/cspell-types": "9.2.1", - "cspell-trie-lib": "9.2.1", - "fast-equals": "^5.2.2" + "@cspell/cspell-pipe": "9.4.0", + "@cspell/cspell-types": "9.4.0", + "cspell-trie-lib": "9.4.0", + "fast-equals": "^5.3.3" }, "engines": { "node": ">=20" } }, "node_modules/cspell-gitignore": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/cspell-gitignore/-/cspell-gitignore-9.2.1.tgz", - "integrity": "sha512-WPnDh03gXZoSqVyXq4L7t9ljx6lTDvkiSRUudb125egEK5e9s04csrQpLI3Yxcnc1wQA2nzDr5rX9XQVvCHf7g==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/cspell-gitignore/-/cspell-gitignore-9.4.0.tgz", + "integrity": "sha512-HMrzLmJBUMSpaMMkltlTAz/aVOrHxixyhKfg5WbFCJ5JYZO6Qu3/JU3wRoOFoud9449wRjLkvrGmbbL2+vO6Lw==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/url": "9.2.1", - "cspell-glob": "9.2.1", - "cspell-io": "9.2.1" + "@cspell/url": "9.4.0", + "cspell-glob": "9.4.0", + "cspell-io": "9.4.0" }, "bin": { "cspell-gitignore": "bin.mjs" @@ -7791,41 +7812,28 @@ } }, "node_modules/cspell-glob": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/cspell-glob/-/cspell-glob-9.2.1.tgz", - "integrity": "sha512-CrT/6ld3rXhB36yWFjrx1SrMQzwDrGOLr+wYEnrWI719/LTYWWCiMFW7H+qhsJDTsR+ku8+OAmfRNBDXvh9mnQ==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/cspell-glob/-/cspell-glob-9.4.0.tgz", + "integrity": "sha512-Q87Suj9oXrhoKck15qWorCizBjMNxG/k3NjnhKIAMrF+PdUa1Mpl0MOD+hqV1Wvwh1UHcIMYCP3bR3XpBbNx+Q==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/url": "9.2.1", + "@cspell/url": "9.4.0", "picomatch": "^4.0.3" }, "engines": { "node": ">=20" } }, - "node_modules/cspell-glob/node_modules/picomatch": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", - "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/jonschlinkert" - } - }, "node_modules/cspell-grammar": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/cspell-grammar/-/cspell-grammar-9.2.1.tgz", - "integrity": "sha512-10RGFG7ZTQPdwyW2vJyfmC1t8813y8QYRlVZ8jRHWzer9NV8QWrGnL83F+gTPXiKR/lqiW8WHmFlXR4/YMV+JQ==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/cspell-grammar/-/cspell-grammar-9.4.0.tgz", + "integrity": "sha512-ie7OQ4Neflo+61bMzoLR7GtlZfMBAm2KL1U4iNqh15wUE5fDbvXeN15H5lu+gcO8BwYvC5wxZknw1x62/J8+3Q==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/cspell-pipe": "9.2.1", - "@cspell/cspell-types": "9.2.1" + "@cspell/cspell-pipe": "9.4.0", + "@cspell/cspell-types": "9.4.0" }, "bin": { "cspell-grammar": "bin.mjs" @@ -7835,45 +7843,43 @@ } }, "node_modules/cspell-io": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/cspell-io/-/cspell-io-9.2.1.tgz", - "integrity": "sha512-v9uWXtRzB+RF/Mzg5qMzpb8/yt+1bwtTt2rZftkLDLrx5ybVvy6rhRQK05gFWHmWVtWEe0P/pIxaG2Vz92C8Ag==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/cspell-io/-/cspell-io-9.4.0.tgz", + "integrity": "sha512-8w30dqlO54H9w6WGlvZhHI5kytVbF3bYPqKJAZLWKEO36L2mdpf6/abx/FA4yVLJ56wmH1x0N0ZK32wNRl5C6A==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/cspell-service-bus": "9.2.1", - "@cspell/url": "9.2.1" + "@cspell/cspell-service-bus": "9.4.0", + "@cspell/url": "9.4.0" }, "engines": { "node": ">=20" } }, "node_modules/cspell-lib": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/cspell-lib/-/cspell-lib-9.2.1.tgz", - "integrity": "sha512-KeB6NHcO0g1knWa7sIuDippC3gian0rC48cvO0B0B0QwhOxNxWVp8cSmkycXjk4ijBZNa++IwFjeK/iEqMdahQ==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/cspell-lib/-/cspell-lib-9.4.0.tgz", + "integrity": "sha512-ajjioE59IEDNUPawfaBpiMfGC32iKPkuYd4T9ftguuef8VvyKRifniiUi1nxwGgAhzSfxHvWs7qdT+29Pp5TMQ==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/cspell-bundled-dicts": "9.2.1", - "@cspell/cspell-pipe": "9.2.1", - "@cspell/cspell-resolver": "9.2.1", - "@cspell/cspell-types": "9.2.1", - "@cspell/dynamic-import": "9.2.1", - "@cspell/filetypes": "9.2.1", - "@cspell/strong-weak-map": "9.2.1", - "@cspell/url": "9.2.1", + "@cspell/cspell-bundled-dicts": "9.4.0", + "@cspell/cspell-pipe": "9.4.0", + "@cspell/cspell-resolver": "9.4.0", + "@cspell/cspell-types": "9.4.0", + "@cspell/dynamic-import": "9.4.0", + "@cspell/filetypes": "9.4.0", + "@cspell/strong-weak-map": "9.4.0", + "@cspell/url": "9.4.0", "clear-module": "^4.1.2", - "comment-json": "^4.2.5", - "cspell-config-lib": "9.2.1", - "cspell-dictionary": "9.2.1", - "cspell-glob": "9.2.1", - "cspell-grammar": "9.2.1", - "cspell-io": "9.2.1", - "cspell-trie-lib": "9.2.1", + "cspell-config-lib": "9.4.0", + "cspell-dictionary": "9.4.0", + "cspell-glob": "9.4.0", + "cspell-grammar": "9.4.0", + "cspell-io": "9.4.0", + "cspell-trie-lib": "9.4.0", "env-paths": "^3.0.0", - "fast-equals": "^5.2.2", - "gensequence": "^7.0.0", + "gensequence": "^8.0.8", "import-fresh": "^3.3.1", "resolve-from": "^5.0.0", "vscode-languageserver-textdocument": "^1.0.12", @@ -7884,48 +7890,26 @@ "node": ">=20" } }, - "node_modules/cspell-lib/node_modules/resolve-from": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", - "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=8" - } - }, "node_modules/cspell-trie-lib": { - "version": "9.2.1", - "resolved": "https://registry.npmjs.org/cspell-trie-lib/-/cspell-trie-lib-9.2.1.tgz", - "integrity": "sha512-qOtbL+/tUzGFHH0Uq2wi7sdB9iTy66QNx85P7DKeRdX9ZH53uQd7qC4nEk+/JPclx1EgXX26svxr0jTGISJhLw==", + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/cspell-trie-lib/-/cspell-trie-lib-9.4.0.tgz", + "integrity": "sha512-bySJTm8XDiJAoC1MDo4lE/KpSNxydo13ZETC8TF7Hb3rbWI1c6o5eZ4+i/tkG3M94OvKV91+MeAvoMCe7GGgAw==", "dev": true, "license": "MIT", "dependencies": { - "@cspell/cspell-pipe": "9.2.1", - "@cspell/cspell-types": "9.2.1", - "gensequence": "^7.0.0" + "@cspell/cspell-pipe": "9.4.0", + "@cspell/cspell-types": "9.4.0", + "gensequence": "^8.0.8" }, "engines": { "node": ">=20" } }, - "node_modules/cspell/node_modules/chalk": { - "version": "5.6.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz", - "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==", - "dev": true, - "license": "MIT", - "engines": { - "node": "^12.17.0 || ^14.13 || >=16.0.0" - }, - "funding": { - "url": "https://github.com/chalk/chalk?sponsor=1" - } - }, "node_modules/debug": { - "version": "4.4.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", - "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==", + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", "dependencies": { "ms": "^2.1.3" }, @@ -7952,7 +7936,8 @@ "version": "0.1.4", "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/defaults": { "version": "1.0.4", @@ -7985,46 +7970,11 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/del": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/del/-/del-7.1.0.tgz", - "integrity": "sha512-v2KyNk7efxhlyHpjEvfyxaAihKKK0nWCuf6ZtqZcFFpQRG0bJ12Qsr0RpvsICMjAAZ8DOVCxrlqpxISlMHC4Kg==", - "dev": true, - "license": "MIT", - "dependencies": { - "globby": "^13.1.2", - "graceful-fs": "^4.2.10", - "is-glob": "^4.0.3", - "is-path-cwd": "^3.0.0", - "is-path-inside": "^4.0.0", - "p-map": "^5.5.0", - "rimraf": "^3.0.2", - "slash": "^4.0.0" - }, - "engines": { - "node": ">=14.16" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/del/node_modules/slash": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz", - "integrity": "sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/depd": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", "engines": { "node": ">= 0.8" } @@ -8034,38 +7984,23 @@ "resolved": "https://registry.npmjs.org/detect-file/-/detect-file-1.0.0.tgz", "integrity": "sha512-DtCOLG98P007x7wiiOmfI0fi3eIKyWiLTGJ2MDnVi/E04lWGbf+JzrRHMm0rgIIZJGtHpKpbVgLWHrv8xXpc3Q==", "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/dir-glob": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", - "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", - "dev": true, "license": "MIT", - "dependencies": { - "path-type": "^4.0.0" - }, "engines": { - "node": ">=8" + "node": ">=0.10.0" } }, - "node_modules/dot-case": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz", - "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==", + "node_modules/dlv": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz", + "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==", "dev": true, - "license": "MIT", - "dependencies": { - "no-case": "^3.0.4", - "tslib": "^2.0.3" - } + "license": "MIT" }, "node_modules/dunder-proto": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "license": "MIT", "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", @@ -8085,32 +8020,35 @@ "node_modules/ee-first": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", - "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==" + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "license": "MIT" }, "node_modules/electron-to-chromium": { - "version": "1.5.159", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.159.tgz", - "integrity": "sha512-CEvHptWAMV5p6GJ0Lq8aheyvVbfzVrv5mmidu1D3pidoVNkB3tTBsTMVtPJ+rzRK5oV229mCLz9Zj/hNvU8GBA==", - "dev": true + "version": "1.5.267", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.267.tgz", + "integrity": "sha512-0Drusm6MVRXSOJpGbaSVgcQsuB4hEkMpHXaVstcPmhu5LIedxs1xNK/nIxmQIU/RPC0+1/o0AVZfBTkTNJOdUw==", + "dev": true, + "license": "ISC" }, "node_modules/emoji-regex": { - "version": "10.4.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz", - "integrity": "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==", - "dev": true + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" }, "node_modules/encodeurl": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", "engines": { "node": ">= 0.8" } }, "node_modules/enhanced-resolve": { - "version": "5.18.3", - "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.18.3.tgz", - "integrity": "sha512-d4lC8xfavMeBjzGr2vECC3fsGXziXZQyJxD868h2M/mBI3PwAuODxAkLkq5HYuvrPYcUtiLzsTo8U3PgX3Ocww==", + "version": "5.18.4", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.18.4.tgz", + "integrity": "sha512-LgQMM4WXU3QI+SYgEc2liRgznaD5ojbmY3sb8LxyguVkIg5FxdpTkvk72te2R38/TGKxH634oLxXRGY6d7AP+Q==", "dev": true, "license": "MIT", "dependencies": { @@ -8139,6 +8077,7 @@ "resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz", "integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -8150,6 +8089,7 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", "engines": { "node": ">= 0.4" } @@ -8158,6 +8098,7 @@ "version": "1.3.0", "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", "engines": { "node": ">= 0.4" } @@ -8173,6 +8114,7 @@ "version": "1.1.1", "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "license": "MIT", "dependencies": { "es-errors": "^1.3.0" }, @@ -8181,9 +8123,9 @@ } }, "node_modules/esbuild": { - "version": "0.25.9", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.9.tgz", - "integrity": "sha512-CRbODhYyQx3qp7ZEwzxOk4JBqmD/seJrzPa/cGjY1VtIn5E09Oi9/dB4JwctnfZ8Q8iT7rioVv5k/FNT/uf54g==", + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.2.tgz", + "integrity": "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==", "dev": true, "hasInstallScript": true, "license": "MIT", @@ -8194,38 +8136,39 @@ "node": ">=18" }, "optionalDependencies": { - "@esbuild/aix-ppc64": "0.25.9", - "@esbuild/android-arm": "0.25.9", - "@esbuild/android-arm64": "0.25.9", - "@esbuild/android-x64": "0.25.9", - "@esbuild/darwin-arm64": "0.25.9", - "@esbuild/darwin-x64": "0.25.9", - "@esbuild/freebsd-arm64": "0.25.9", - "@esbuild/freebsd-x64": "0.25.9", - "@esbuild/linux-arm": "0.25.9", - "@esbuild/linux-arm64": "0.25.9", - "@esbuild/linux-ia32": "0.25.9", - "@esbuild/linux-loong64": "0.25.9", - "@esbuild/linux-mips64el": "0.25.9", - "@esbuild/linux-ppc64": "0.25.9", - "@esbuild/linux-riscv64": "0.25.9", - "@esbuild/linux-s390x": "0.25.9", - "@esbuild/linux-x64": "0.25.9", - "@esbuild/netbsd-arm64": "0.25.9", - "@esbuild/netbsd-x64": "0.25.9", - "@esbuild/openbsd-arm64": "0.25.9", - "@esbuild/openbsd-x64": "0.25.9", - "@esbuild/openharmony-arm64": "0.25.9", - "@esbuild/sunos-x64": "0.25.9", - "@esbuild/win32-arm64": "0.25.9", - "@esbuild/win32-ia32": "0.25.9", - "@esbuild/win32-x64": "0.25.9" + "@esbuild/aix-ppc64": "0.27.2", + "@esbuild/android-arm": "0.27.2", + "@esbuild/android-arm64": "0.27.2", + "@esbuild/android-x64": "0.27.2", + "@esbuild/darwin-arm64": "0.27.2", + "@esbuild/darwin-x64": "0.27.2", + "@esbuild/freebsd-arm64": "0.27.2", + "@esbuild/freebsd-x64": "0.27.2", + "@esbuild/linux-arm": "0.27.2", + "@esbuild/linux-arm64": "0.27.2", + "@esbuild/linux-ia32": "0.27.2", + "@esbuild/linux-loong64": "0.27.2", + "@esbuild/linux-mips64el": "0.27.2", + "@esbuild/linux-ppc64": "0.27.2", + "@esbuild/linux-riscv64": "0.27.2", + "@esbuild/linux-s390x": "0.27.2", + "@esbuild/linux-x64": "0.27.2", + "@esbuild/netbsd-arm64": "0.27.2", + "@esbuild/netbsd-x64": "0.27.2", + "@esbuild/openbsd-arm64": "0.27.2", + "@esbuild/openbsd-x64": "0.27.2", + "@esbuild/openharmony-arm64": "0.27.2", + "@esbuild/sunos-x64": "0.27.2", + "@esbuild/win32-arm64": "0.27.2", + "@esbuild/win32-ia32": "0.27.2", + "@esbuild/win32-x64": "0.27.2" } }, "node_modules/escalade": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "license": "MIT", "engines": { "node": ">=6" } @@ -8233,13 +8176,15 @@ "node_modules/escape-html": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", - "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==" + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "license": "MIT" }, "node_modules/escape-string-regexp": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", "dev": true, + "license": "MIT", "engines": { "node": ">=10" }, @@ -8248,32 +8193,32 @@ } }, "node_modules/eslint": { - "version": "9.27.0", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.27.0.tgz", - "integrity": "sha512-ixRawFQuMB9DZ7fjU3iGGganFDp3+45bPOdaRurcFHSXO1e/sYwUX/FtQZpLZJR6SjMoJH8hR2pPEAfDyCoU2Q==", + "version": "9.39.2", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.2.tgz", + "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==", "dev": true, + "license": "MIT", "dependencies": { - "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.1", - "@eslint/config-array": "^0.20.0", - "@eslint/config-helpers": "^0.2.1", - "@eslint/core": "^0.14.0", + "@eslint/config-array": "^0.21.1", + "@eslint/config-helpers": "^0.4.2", + "@eslint/core": "^0.17.0", "@eslint/eslintrc": "^3.3.1", - "@eslint/js": "9.27.0", - "@eslint/plugin-kit": "^0.3.1", + "@eslint/js": "9.39.2", + "@eslint/plugin-kit": "^0.4.1", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", "@types/estree": "^1.0.6", - "@types/json-schema": "^7.0.15", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.6", "debug": "^4.3.2", "escape-string-regexp": "^4.0.0", - "eslint-scope": "^8.3.0", - "eslint-visitor-keys": "^4.2.0", - "espree": "^10.3.0", + "eslint-scope": "^8.4.0", + "eslint-visitor-keys": "^4.2.1", + "espree": "^10.4.0", "esquery": "^1.5.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", @@ -8362,9 +8307,9 @@ } }, "node_modules/eslint-plugin-n": { - "version": "17.21.3", - "resolved": "https://registry.npmjs.org/eslint-plugin-n/-/eslint-plugin-n-17.21.3.tgz", - "integrity": "sha512-MtxYjDZhMQgsWRm/4xYLL0i2EhusWT7itDxlJ80l1NND2AL2Vi5Mvneqv/ikG9+zpran0VsVRXTEHrpLmUZRNw==", + "version": "17.23.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-n/-/eslint-plugin-n-17.23.1.tgz", + "integrity": "sha512-68PealUpYoHOBh332JLLD9Sj7OQUDkFpmcfqt8R9sySfFSeuGJjMTJQvCRRB96zO3A/PELRLkPrzsHmzEFQQ5A==", "dev": true, "license": "MIT", "dependencies": { @@ -8443,9 +8388,9 @@ } }, "node_modules/eslint-plugin-unused-imports": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-unused-imports/-/eslint-plugin-unused-imports-4.2.0.tgz", - "integrity": "sha512-hLbJ2/wnjKq4kGA9AUaExVFIbNzyxYdVo49QZmKCnhk5pc9wcYRbfgLHvWJ8tnsdcseGhoUAddm9gn/lt+d74w==", + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-unused-imports/-/eslint-plugin-unused-imports-4.3.0.tgz", + "integrity": "sha512-ZFBmXMGBYfHttdRtOG9nFFpmUvMtbHSjsKrS20vdWdbfiVYsO3yA2SGYy9i9XmZJDfMGBflZGBCm70SEnFQtOA==", "dev": true, "license": "MIT", "peerDependencies": { @@ -8459,10 +8404,11 @@ } }, "node_modules/eslint-scope": { - "version": "8.3.0", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.3.0.tgz", - "integrity": "sha512-pUNxi75F8MJ/GdeKtVLSbYg4ZI34J6C0C7sbL4YOp2exGwen7ZsuBqKzUhXd0qMQ362yET3z+uPwKeg/0C2XCQ==", + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz", + "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" @@ -8479,6 +8425,7 @@ "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" }, @@ -8486,6 +8433,39 @@ "url": "https://opencollective.com/eslint" } }, + "node_modules/eslint/node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/eslint/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, "node_modules/eslint/node_modules/brace-expansion": { "version": "1.1.12", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", @@ -8497,11 +8477,29 @@ "concat-map": "0.0.1" } }, + "node_modules/eslint/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, "node_modules/eslint/node_modules/eslint-visitor-keys": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz", - "integrity": "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, @@ -8514,15 +8512,24 @@ "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", "dev": true, + "license": "MIT", "engines": { "node": ">= 4" } }, + "node_modules/eslint/node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "license": "MIT" + }, "node_modules/eslint/node_modules/minimatch": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "dev": true, + "license": "ISC", "dependencies": { "brace-expansion": "^1.1.7" }, @@ -8531,14 +8538,15 @@ } }, "node_modules/espree": { - "version": "10.3.0", - "resolved": "https://registry.npmjs.org/espree/-/espree-10.3.0.tgz", - "integrity": "sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==", + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz", + "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { - "acorn": "^8.14.0", + "acorn": "^8.15.0", "acorn-jsx": "^5.3.2", - "eslint-visitor-keys": "^4.2.0" + "eslint-visitor-keys": "^4.2.1" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -8548,10 +8556,11 @@ } }, "node_modules/espree/node_modules/eslint-visitor-keys": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz", - "integrity": "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, @@ -8574,10 +8583,11 @@ } }, "node_modules/esquery": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz", - "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==", + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz", + "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==", "dev": true, + "license": "BSD-3-Clause", "dependencies": { "estraverse": "^5.1.0" }, @@ -8590,6 +8600,7 @@ "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "estraverse": "^5.2.0" }, @@ -8602,6 +8613,7 @@ "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", "dev": true, + "license": "BSD-2-Clause", "engines": { "node": ">=4.0" } @@ -8621,6 +8633,7 @@ "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", "dev": true, + "license": "BSD-2-Clause", "engines": { "node": ">=0.10.0" } @@ -8629,6 +8642,7 @@ "version": "1.8.1", "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "license": "MIT", "engines": { "node": ">= 0.6" } @@ -8637,12 +8651,14 @@ "version": "5.0.1", "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz", "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/eventsource": { "version": "3.0.7", "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz", "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==", + "license": "MIT", "dependencies": { "eventsource-parser": "^3.0.1" }, @@ -8651,9 +8667,10 @@ } }, "node_modules/eventsource-parser": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.2.tgz", - "integrity": "sha512-6RxOBZ/cYgd8usLwsEl+EC09Au/9BcmCKYF2/xbml6DNczf7nv0MQb+7BA2F+li6//I+28VNlQR37XfQtcAJuA==", + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.6.tgz", + "integrity": "sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==", + "license": "MIT", "engines": { "node": ">=18.0.0" } @@ -8663,6 +8680,7 @@ "resolved": "https://registry.npmjs.org/expand-tilde/-/expand-tilde-2.0.2.tgz", "integrity": "sha512-A5EmesHW6rfnZ9ysHQjPdJRni0SRar0tjtG5MNtm9n5TUvsYU8oozprtRD4AqHxcZWWlVuAmQo2nWKfN9oyjTw==", "dev": true, + "license": "MIT", "dependencies": { "homedir-polyfill": "^1.0.1" }, @@ -8671,9 +8689,9 @@ } }, "node_modules/expect-type": { - "version": "1.2.2", - "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.2.2.tgz", - "integrity": "sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==", + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", + "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", "dev": true, "license": "Apache-2.0", "engines": { @@ -8681,18 +8699,19 @@ } }, "node_modules/express": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/express/-/express-5.1.0.tgz", - "integrity": "sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==", + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz", + "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==", "license": "MIT", "dependencies": { "accepts": "^2.0.0", - "body-parser": "^2.2.0", + "body-parser": "^2.2.1", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.0", + "depd": "^2.0.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", @@ -8723,9 +8742,10 @@ } }, "node_modules/express-rate-limit": { - "version": "7.5.0", - "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.0.tgz", - "integrity": "sha512-eB5zbQh5h+VenMPM3fh+nw1YExi5nMr6HUCR62ELSP11huvxm/Uir1H1QEyTkk5QX6A58pX6NmaTMceKZ0Eodg==", + "version": "7.5.1", + "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.1.tgz", + "integrity": "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==", + "license": "MIT", "engines": { "node": ">= 16" }, @@ -8733,46 +8753,20 @@ "url": "https://github.com/sponsors/express-rate-limit" }, "peerDependencies": { - "express": "^4.11 || 5 || ^5.0.0-beta.1" + "express": ">= 4.11" } }, "node_modules/extend": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", - "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==" - }, - "node_modules/external-editor": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz", - "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==", - "dev": true, - "license": "MIT", - "dependencies": { - "chardet": "^0.7.0", - "iconv-lite": "^0.4.24", - "tmp": "^0.0.33" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/external-editor/node_modules/iconv-lite": { - "version": "0.4.24", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", - "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", - "dev": true, - "license": "MIT", - "dependencies": { - "safer-buffer": ">= 2.1.2 < 3" - }, - "engines": { - "node": ">=0.10.0" - } + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "license": "MIT" }, "node_modules/fast-deep-equal": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", - "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==" + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "license": "MIT" }, "node_modules/fast-diff": { "version": "1.3.0", @@ -8782,54 +8776,28 @@ "license": "Apache-2.0" }, "node_modules/fast-equals": { - "version": "5.3.2", - "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.3.2.tgz", - "integrity": "sha512-6rxyATwPCkaFIL3JLqw8qXqMpIZ942pTX/tbQFkRsDGblS8tNGtlUauA/+mt6RUfqn/4MoEr+WDkYoIQbibWuQ==", + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.4.0.tgz", + "integrity": "sha512-jt2DW/aNFNwke7AUd+Z+e6pz39KO5rzdbbFCg2sGafS4mk13MI7Z8O5z9cADNn5lhGODIgLwug6TZO2ctf7kcw==", "dev": true, "license": "MIT", "engines": { "node": ">=6.0.0" } }, - "node_modules/fast-glob": { - "version": "3.3.3", - "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", - "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", - "dev": true, - "dependencies": { - "@nodelib/fs.stat": "^2.0.2", - "@nodelib/fs.walk": "^1.2.3", - "glob-parent": "^5.1.2", - "merge2": "^1.3.0", - "micromatch": "^4.0.8" - }, - "engines": { - "node": ">=8.6.0" - } - }, - "node_modules/fast-glob/node_modules/glob-parent": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", - "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", - "dev": true, - "dependencies": { - "is-glob": "^4.0.1" - }, - "engines": { - "node": ">= 6" - } - }, "node_modules/fast-json-stable-stringify": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/fast-levenshtein": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/fast-uri": { "version": "3.1.0", @@ -8847,13 +8815,22 @@ ], "license": "BSD-3-Clause" }, - "node_modules/fastq": { - "version": "1.19.1", - "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz", - "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==", - "dev": true, - "dependencies": { - "reusify": "^1.0.4" + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } } }, "node_modules/file-entry-cache": { @@ -8861,6 +8838,7 @@ "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", "dev": true, + "license": "MIT", "dependencies": { "flat-cache": "^4.0.0" }, @@ -8873,6 +8851,7 @@ "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", "dev": true, + "license": "MIT", "dependencies": { "to-regex-range": "^5.0.1" }, @@ -8881,9 +8860,10 @@ } }, "node_modules/finalhandler": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz", - "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz", + "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==", + "license": "MIT", "dependencies": { "debug": "^4.4.0", "encodeurl": "^2.0.0", @@ -8893,7 +8873,11 @@ "statuses": "^2.0.1" }, "engines": { - "node": ">= 0.8" + "node": ">= 18.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/find-up": { @@ -8901,6 +8885,7 @@ "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", "dev": true, + "license": "MIT", "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" @@ -8927,6 +8912,7 @@ "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-5.0.0.tgz", "integrity": "sha512-MzwXju70AuyflbgeOhzvQWAvvQdo1XL0A9bVvlXsYcFEBM87WR4OakL4OfZq+QRmr+duJubio+UtNQCPsVESzQ==", "dev": true, + "license": "MIT", "dependencies": { "detect-file": "^1.0.0", "is-glob": "^4.0.3", @@ -8942,6 +8928,7 @@ "resolved": "https://registry.npmjs.org/fined/-/fined-2.0.0.tgz", "integrity": "sha512-OFRzsL6ZMHz5s0JrsEr+TpdGNCtrVtnuG3x1yzGNiQHT0yaDnXAj8V/lWcpJVrnoDpcwXcASxAZYbuXda2Y82A==", "dev": true, + "license": "MIT", "dependencies": { "expand-tilde": "^2.0.2", "is-plain-object": "^5.0.0", @@ -8958,6 +8945,7 @@ "resolved": "https://registry.npmjs.org/flagged-respawn/-/flagged-respawn-2.0.0.tgz", "integrity": "sha512-Gq/a6YCi8zexmGHMuJwahTGzXlAZAOsbCVKduWXC6TlLCjjFRlExMJc4GC2NYPYZ0r/brw9P7CpRgQmlPVeOoA==", "dev": true, + "license": "MIT", "engines": { "node": ">= 10.13.0" } @@ -8967,6 +8955,7 @@ "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", "dev": true, + "license": "MIT", "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.4" @@ -8979,13 +8968,15 @@ "version": "3.3.3", "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz", "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==", - "dev": true + "dev": true, + "license": "ISC" }, "node_modules/for-in": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", "integrity": "sha512-7EwmXrOjyL+ChxMhmG5lnW9MPt1aIeZEwKhQzoBUdTV0N3zuwWDZYVJatDvZ2OyzPUvdIAZDsCetk3coyMfcnQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -8995,6 +8986,7 @@ "resolved": "https://registry.npmjs.org/for-own/-/for-own-1.0.0.tgz", "integrity": "sha512-0OABksIGrxKK8K4kynWkQ7y1zounQxP+CWnyclVwj81KW3vlLlGUx57DKGcP/LH216GzqnstnPocF16Nxs0Ycg==", "dev": true, + "license": "MIT", "dependencies": { "for-in": "^1.0.1" }, @@ -9019,23 +9011,11 @@ "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/foreground-child/node_modules/signal-exit": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", - "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", - "dev": true, - "license": "ISC", - "engines": { - "node": ">=14" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, "node_modules/forwarded": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", "engines": { "node": ">= 0.6" } @@ -9050,6 +9030,7 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz", "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==", + "license": "MIT", "engines": { "node": ">= 0.8" } @@ -9069,18 +9050,13 @@ "node": ">=12" } }, - "node_modules/fs.realpath": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", - "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", - "dev": true - }, "node_modules/fsevents": { "version": "2.3.3", "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", "dev": true, "hasInstallScript": true, + "license": "MIT", "optional": true, "os": [ "darwin" @@ -9093,6 +9069,7 @@ "version": "1.1.2", "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -9128,13 +9105,13 @@ } }, "node_modules/gensequence": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/gensequence/-/gensequence-7.0.0.tgz", - "integrity": "sha512-47Frx13aZh01afHJTB3zTtKIlFI6vWY+MYCN9Qpew6i52rfKjnhCF/l1YlC8UmEMvvntZZ6z4PiCcmyuedR2aQ==", + "version": "8.0.8", + "resolved": "https://registry.npmjs.org/gensequence/-/gensequence-8.0.8.tgz", + "integrity": "sha512-omMVniXEXpdx/vKxGnPRoO2394Otlze28TyxECbFVyoSpZ9H3EO7lemjcB12OpQJzRW4e5tt/dL1rOxry6aMHg==", "dev": true, "license": "MIT", "engines": { - "node": ">=18" + "node": ">=20" } }, "node_modules/gensync": { @@ -9142,6 +9119,7 @@ "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.9.0" } @@ -9156,10 +9134,11 @@ } }, "node_modules/get-east-asian-width": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.3.0.tgz", - "integrity": "sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==", + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.4.0.tgz", + "integrity": "sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -9171,6 +9150,7 @@ "version": "1.3.0", "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "license": "MIT", "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", @@ -9194,6 +9174,7 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "license": "MIT", "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" @@ -9203,9 +9184,9 @@ } }, "node_modules/get-tsconfig": { - "version": "4.10.1", - "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.1.tgz", - "integrity": "sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==", + "version": "4.13.0", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.0.tgz", + "integrity": "sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==", "dev": true, "license": "MIT", "dependencies": { @@ -9216,21 +9197,21 @@ } }, "node_modules/glob": { - "version": "7.2.3", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", - "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", - "deprecated": "Glob versions prior to v9 are no longer supported", + "version": "10.5.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz", + "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==", "dev": true, + "license": "ISC", "dependencies": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.1.1", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" + "foreground-child": "^3.1.0", + "jackspeak": "^3.1.2", + "minimatch": "^9.0.4", + "minipass": "^7.1.2", + "package-json-from-dist": "^1.0.0", + "path-scurry": "^1.11.1" }, - "engines": { - "node": "*" + "bin": { + "glob": "dist/esm/bin.mjs" }, "funding": { "url": "https://github.com/sponsors/isaacs" @@ -9241,6 +9222,7 @@ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", "dev": true, + "license": "ISC", "dependencies": { "is-glob": "^4.0.3" }, @@ -9248,29 +9230,6 @@ "node": ">=10.13.0" } }, - "node_modules/glob/node_modules/brace-expansion": { - "version": "1.1.12", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", - "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", - "dev": true, - "license": "MIT", - "dependencies": { - "balanced-match": "^1.0.0", - "concat-map": "0.0.1" - } - }, - "node_modules/glob/node_modules/minimatch": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", - "dev": true, - "dependencies": { - "brace-expansion": "^1.1.7" - }, - "engines": { - "node": "*" - } - }, "node_modules/global-directory": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/global-directory/-/global-directory-4.0.1.tgz", @@ -9287,21 +9246,12 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/global-directory/node_modules/ini": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.1.tgz", - "integrity": "sha512-QQnnxNyfvmHFIsj7gkPcYymR8Jdw/o7mp5ZFihxn6h8Ci6fh3Dx4E1gPjpQEpIuPo9XVNY/ZUwh4BPMjGyL01g==", - "dev": true, - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, "node_modules/global-modules": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-1.0.0.tgz", "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==", "dev": true, + "license": "MIT", "dependencies": { "global-prefix": "^1.0.1", "is-windows": "^1.0.1", @@ -9316,6 +9266,7 @@ "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-1.0.2.tgz", "integrity": "sha512-5lsx1NUDHtSjfg0eHlmYvZKv8/nVqX4ckFbM+FrGcQ+04KWcWFo9P5MxPZYSzUvyzmdTbI7Eix8Q4IbELDqzKg==", "dev": true, + "license": "MIT", "dependencies": { "expand-tilde": "^2.0.2", "homedir-polyfill": "^1.0.1", @@ -9327,11 +9278,19 @@ "node": ">=0.10.0" } }, + "node_modules/global-prefix/node_modules/ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", + "dev": true, + "license": "ISC" + }, "node_modules/global-prefix/node_modules/which": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", "dev": true, + "license": "ISC", "dependencies": { "isexe": "^2.0.0" }, @@ -9340,9 +9299,9 @@ } }, "node_modules/globals": { - "version": "16.3.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-16.3.0.tgz", - "integrity": "sha512-bqWEnJ1Nt3neqx2q5SFfGS8r/ahumIakg3HcwtNlrVlwXIeNumWn/c7Pn/wKzGhf6SaW6H6uWXLqC30STCMchQ==", + "version": "16.5.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-16.5.0.tgz", + "integrity": "sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==", "dev": true, "license": "MIT", "engines": { @@ -9352,49 +9311,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/globby": { - "version": "13.2.2", - "resolved": "https://registry.npmjs.org/globby/-/globby-13.2.2.tgz", - "integrity": "sha512-Y1zNGV+pzQdh7H39l9zgB4PJqjRNqydvdYCDG4HFXM4XuvSaQQlEc91IU1yALL8gUTDomgBAfz3XJdmUS+oo0w==", - "dev": true, - "license": "MIT", - "dependencies": { - "dir-glob": "^3.0.1", - "fast-glob": "^3.3.0", - "ignore": "^5.2.4", - "merge2": "^1.4.1", - "slash": "^4.0.0" - }, - "engines": { - "node": "^12.20.0 || ^14.13.1 || >=16.0.0" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/globby/node_modules/ignore": { - "version": "5.3.2", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", - "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 4" - } - }, - "node_modules/globby/node_modules/slash": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz", - "integrity": "sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/globrex": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/globrex/-/globrex-0.1.2.tgz", @@ -9415,6 +9331,7 @@ "version": "1.2.0", "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -9426,13 +9343,8 @@ "version": "4.2.11", "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", - "dev": true - }, - "node_modules/graphemer": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", - "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", - "dev": true + "dev": true, + "license": "ISC" }, "node_modules/handlebars": { "version": "4.7.8", @@ -9461,6 +9373,7 @@ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } @@ -9482,6 +9395,7 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -9493,6 +9407,7 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", "dependencies": { "function-bind": "^1.1.2" }, @@ -9500,22 +9415,12 @@ "node": ">= 0.4" } }, - "node_modules/header-case": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/header-case/-/header-case-2.0.4.tgz", - "integrity": "sha512-H/vuk5TEEVZwrR0lp2zed9OCo1uAILMlx0JEMgC26rzyJJ3N1v6XkwHHXJQdR2doSjcGPM6OKPYoJgf0plJ11Q==", - "dev": true, - "license": "MIT", - "dependencies": { - "capital-case": "^1.0.4", - "tslib": "^2.0.3" - } - }, "node_modules/homedir-polyfill": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz", "integrity": "sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==", "dev": true, + "license": "MIT", "dependencies": { "parse-passwd": "^1.0.0" }, @@ -9523,25 +9428,41 @@ "node": ">=0.10.0" } }, + "node_modules/hono": { + "version": "4.11.3", + "resolved": "https://registry.npmjs.org/hono/-/hono-4.11.3.tgz", + "integrity": "sha512-PmQi306+M/ct/m5s66Hrg+adPnkD5jiO6IjA7WhWw0gSBSo1EcRegwuI1deZ+wd5pzCGynCcn2DprnE4/yEV4w==", + "license": "MIT", + "peer": true, + "engines": { + "node": ">=16.9.0" + } + }, "node_modules/html-escaper": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/http-errors": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", - "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "license": "MIT", "dependencies": { - "depd": "2.0.0", - "inherits": "2.0.4", - "setprototypeof": "1.2.0", - "statuses": "2.0.1", - "toidentifier": "1.0.1" + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" }, "engines": { "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/https-proxy-agent": { @@ -9562,6 +9483,7 @@ "resolved": "https://registry.npmjs.org/husky/-/husky-9.1.7.tgz", "integrity": "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==", "dev": true, + "license": "MIT", "bin": { "husky": "bin.js" }, @@ -9573,14 +9495,19 @@ } }, "node_modules/iconv-lite": { - "version": "0.6.3", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", - "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.1.tgz", + "integrity": "sha512-2Tth85cXwGFHfvRgZWszZSvdo+0Xsqmw8k8ZwxScfcBneNUraK+dxRxRm24nszx80Y0TVio8kKLt5sLE7ZCLlw==", + "license": "MIT", "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" }, "engines": { "node": ">=0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/ieee754": { @@ -9605,10 +9532,11 @@ "license": "BSD-3-Clause" }, "node_modules/ignore": { - "version": "7.0.4", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.4.tgz", - "integrity": "sha512-gJzzk+PQNznz8ysRrC0aOkBNVRBDtE1n53IqyqEf3PXrYwomFs5q4pGMizBMJF+ykh03insJ27hB8gSrD2Hn8A==", + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz", + "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==", "dev": true, + "license": "MIT", "engines": { "node": ">= 4" } @@ -9618,6 +9546,7 @@ "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", "dev": true, + "license": "MIT", "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" @@ -9629,6 +9558,29 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/import-fresh/node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/import-fresh/node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, "node_modules/import-in-the-middle": { "version": "1.15.0", "resolved": "https://registry.npmjs.org/import-in-the-middle/-/import-in-the-middle-1.15.0.tgz", @@ -9657,56 +9609,38 @@ "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", "dev": true, - "engines": { - "node": ">=0.8.19" - } - }, - "node_modules/indent-string": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz", - "integrity": "sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==", - "dev": true, "license": "MIT", "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/inflight": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", - "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", - "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", - "dev": true, - "dependencies": { - "once": "^1.3.0", - "wrappy": "1" + "node": ">=0.8.19" } }, "node_modules/inherits": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" }, "node_modules/ini": { - "version": "1.3.8", - "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", - "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", - "dev": true + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.1.tgz", + "integrity": "sha512-QQnnxNyfvmHFIsj7gkPcYymR8Jdw/o7mp5ZFihxn6h8Ci6fh3Dx4E1gPjpQEpIuPo9XVNY/ZUwh4BPMjGyL01g==", + "dev": true, + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } }, "node_modules/inquirer": { - "version": "9.3.7", - "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-9.3.7.tgz", - "integrity": "sha512-LJKFHCSeIRq9hanN14IlOtPSTe3lNES7TYDTE2xxdAy1LS5rYphajK1qtwvj3YmQXvvk0U2Vbmcni8P9EIQW9w==", + "version": "9.3.8", + "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-9.3.8.tgz", + "integrity": "sha512-pFGGdaHrmRKMh4WoDDSowddgjT1Vkl90atobmTeSmcPGdYiwikch/m/Ef5wRaiamHejtw0cUUMMerzDUXCci2w==", "dev": true, "license": "MIT", "dependencies": { + "@inquirer/external-editor": "^1.0.2", "@inquirer/figures": "^1.0.3", "ansi-escapes": "^4.3.2", "cli-width": "^4.1.0", - "external-editor": "^3.1.0", "mute-stream": "1.0.0", "ora": "^5.4.1", "run-async": "^3.0.0", @@ -9720,110 +9654,54 @@ "node": ">=18" } }, - "node_modules/inquirer/node_modules/cli-cursor": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz", - "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==", + "node_modules/inquirer/node_modules/ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", "dev": true, "license": "MIT", "dependencies": { - "restore-cursor": "^3.1.0" + "type-fest": "^0.21.3" }, "engines": { "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/inquirer/node_modules/emoji-regex": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "dev": true, - "license": "MIT" - }, - "node_modules/inquirer/node_modules/is-fullwidth-code-point": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", - "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "node_modules/inquirer/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, "license": "MIT", "engines": { "node": ">=8" } }, - "node_modules/inquirer/node_modules/is-interactive": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-1.0.0.tgz", - "integrity": "sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=8" - } - }, - "node_modules/inquirer/node_modules/is-unicode-supported": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", - "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/inquirer/node_modules/log-symbols": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", - "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", - "dev": true, - "license": "MIT", - "dependencies": { - "chalk": "^4.1.0", - "is-unicode-supported": "^0.1.0" - }, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/inquirer/node_modules/ora": { - "version": "5.4.1", - "resolved": "https://registry.npmjs.org/ora/-/ora-5.4.1.tgz", - "integrity": "sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==", + "node_modules/inquirer/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "license": "MIT", "dependencies": { - "bl": "^4.1.0", - "chalk": "^4.1.0", - "cli-cursor": "^3.1.0", - "cli-spinners": "^2.5.0", - "is-interactive": "^1.0.0", - "is-unicode-supported": "^0.1.0", - "log-symbols": "^4.1.0", - "strip-ansi": "^6.0.0", - "wcwidth": "^1.0.1" + "color-convert": "^2.0.1" }, "engines": { - "node": ">=10" + "node": ">=8" }, "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, - "node_modules/inquirer/node_modules/restore-cursor": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz", - "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==", + "node_modules/inquirer/node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "dev": true, "license": "MIT", - "dependencies": { - "onetime": "^5.1.0", - "signal-exit": "^3.0.2" - }, "engines": { "node": ">=8" } @@ -9843,6 +9721,19 @@ "node": ">=8" } }, + "node_modules/inquirer/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/inquirer/node_modules/wrap-ansi": { "version": "6.2.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz", @@ -9872,6 +9763,7 @@ "version": "1.9.1", "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "license": "MIT", "engines": { "node": ">= 0.10" } @@ -9881,6 +9773,7 @@ "resolved": "https://registry.npmjs.org/is-absolute/-/is-absolute-1.0.0.tgz", "integrity": "sha512-dOWoqflvcydARa360Gvv18DZ/gRuHKi2NU/wU5X1ZFzdYfH29nkiNZsF3mp4OJ3H4yo9Mx8A/uAGNzpzPN3yBA==", "dev": true, + "license": "MIT", "dependencies": { "is-relative": "^1.0.0", "is-windows": "^1.0.1" @@ -9889,23 +9782,11 @@ "node": ">=0.10.0" } }, - "node_modules/is-binary-path": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", - "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", - "dev": true, - "license": "MIT", - "dependencies": { - "binary-extensions": "^2.0.0" - }, - "engines": { - "node": ">=8" - } - }, "node_modules/is-core-module": { "version": "2.16.1", "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "license": "MIT", "dependencies": { "hasown": "^2.0.2" }, @@ -9937,17 +9818,22 @@ "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/is-fullwidth-code-point": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz", - "integrity": "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.1.0.tgz", + "integrity": "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==", "dev": true, + "license": "MIT", + "dependencies": { + "get-east-asian-width": "^1.3.1" + }, "engines": { - "node": ">=12" + "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" @@ -9958,6 +9844,7 @@ "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", "dev": true, + "license": "MIT", "dependencies": { "is-extglob": "^2.1.1" }, @@ -9966,16 +9853,13 @@ } }, "node_modules/is-interactive": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-2.0.0.tgz", - "integrity": "sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==", + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-1.0.0.tgz", + "integrity": "sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==", "dev": true, "license": "MIT", "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "node": ">=8" } }, "node_modules/is-number": { @@ -9983,34 +9867,9 @@ "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", "dev": true, - "engines": { - "node": ">=0.12.0" - } - }, - "node_modules/is-path-cwd": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-3.0.0.tgz", - "integrity": "sha512-kyiNFFLU0Ampr6SDZitD/DwUo4Zs1nSdnygUBqsu3LooL00Qvb5j+UnvApUn/TTj1J3OuE6BTdQ5rudKmU2ZaA==", - "dev": true, - "license": "MIT", - "engines": { - "node": "^12.20.0 || ^14.13.1 || >=16.0.0" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/is-path-inside": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-4.0.0.tgz", - "integrity": "sha512-lJJV/5dYS+RcL8uQdBDW9c9uWFLLBNRyFhnAKXw5tVqLlKZ4RMGZKv+YQ/IA3OhD+RpbJa1LLFM1FQPGyIXvOA==", - "dev": true, "license": "MIT", "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "node": ">=0.12.0" } }, "node_modules/is-plain-object": { @@ -10018,6 +9877,7 @@ "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz", "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -10025,13 +9885,15 @@ "node_modules/is-promise": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz", - "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==" + "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==", + "license": "MIT" }, "node_modules/is-relative": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/is-relative/-/is-relative-1.0.0.tgz", "integrity": "sha512-Kw/ReK0iqwKeu0MITLFuj0jbPAmEiOsIwyIXvvbfa6QfmN9pkD1M+8pdk7Rl/dTKbH34/XBFMbgD4iMJhLQbGA==", "dev": true, + "license": "MIT", "dependencies": { "is-unc-path": "^1.0.0" }, @@ -10056,6 +9918,7 @@ "resolved": "https://registry.npmjs.org/is-unc-path/-/is-unc-path-1.0.0.tgz", "integrity": "sha512-mrGpVd0fs7WWLfVsStvgF6iEJnbjDFZh9/emhRDcGWTduTfNHd9CHeUwH3gYIjdbwo4On6hunkztwOaAw0yllQ==", "dev": true, + "license": "MIT", "dependencies": { "unc-path-regex": "^0.1.2" }, @@ -10064,13 +9927,13 @@ } }, "node_modules/is-unicode-supported": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz", - "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==", + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", + "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", "dev": true, "license": "MIT", "engines": { - "node": ">=18" + "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" @@ -10081,6 +9944,7 @@ "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -10106,9 +9970,9 @@ "license": "MIT" }, "node_modules/isbinaryfile": { - "version": "5.0.4", - "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-5.0.4.tgz", - "integrity": "sha512-YKBKVkKhty7s8rxddb40oOkuP0NbaeXrQvLin6QMHL7Ypiy2RW9LwOVrVgZRyOrhQlayMd9t+D8yDy8MKFTSDQ==", + "version": "5.0.7", + "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-5.0.7.tgz", + "integrity": "sha512-gnWD14Jh3FzS3CPhF0AxNOJ8CxqeblPTADzI38r0wt8ZyQl5edpy75myt08EG2oKvpyiqSqsx+Wkz9vtkbTqYQ==", "dev": true, "license": "MIT", "engines": { @@ -10121,13 +9985,15 @@ "node_modules/isexe": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==" + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "license": "ISC" }, "node_modules/isobject": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -10137,6 +10003,7 @@ "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz", "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==", "dev": true, + "license": "BSD-3-Clause", "engines": { "node": ">=8" } @@ -10146,6 +10013,7 @@ "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-6.0.3.tgz", "integrity": "sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==", "dev": true, + "license": "BSD-3-Clause", "dependencies": { "@babel/core": "^7.23.9", "@babel/parser": "^7.23.9", @@ -10162,6 +10030,7 @@ "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz", "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==", "dev": true, + "license": "BSD-3-Clause", "dependencies": { "istanbul-lib-coverage": "^3.0.0", "make-dir": "^4.0.0", @@ -10171,11 +10040,27 @@ "node": ">=10" } }, + "node_modules/istanbul-lib-source-maps": { + "version": "5.0.6", + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-5.0.6.tgz", + "integrity": "sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.23", + "debug": "^4.1.1", + "istanbul-lib-coverage": "^3.0.0" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/istanbul-reports": { - "version": "3.1.7", - "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.7.tgz", - "integrity": "sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==", + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz", + "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==", "dev": true, + "license": "BSD-3-Clause", "dependencies": { "html-escaper": "^2.0.0", "istanbul-lib-report": "^3.0.0" @@ -10185,32 +10070,43 @@ } }, "node_modules/jackspeak": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.1.1.tgz", - "integrity": "sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==", + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", + "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/cliui": "^8.0.2" }, - "engines": { - "node": "20 || >=22" - }, "funding": { "url": "https://github.com/sponsors/isaacs" + }, + "optionalDependencies": { + "@pkgjs/parseargs": "^0.11.0" + } + }, + "node_modules/jose": { + "version": "6.1.3", + "resolved": "https://registry.npmjs.org/jose/-/jose-6.1.3.tgz", + "integrity": "sha512-0TpaTfihd4QMNwrz/ob2Bp7X04yuxJkjRGi4aKmOqwhov54i6u79oCv7T+C7lo70MKH6BesI3vscD1yb/yzKXQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/panva" } }, "node_modules/js-tokens": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/js-yaml": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", - "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", + "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", "dev": true, + "license": "MIT", "dependencies": { "argparse": "^2.0.1" }, @@ -10223,6 +10119,7 @@ "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", "dev": true, + "license": "MIT", "bin": { "jsesc": "bin/jsesc" }, @@ -10243,13 +10140,20 @@ "version": "3.0.1", "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/json-schema-traverse": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", - "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", - "dev": true + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "license": "MIT" + }, + "node_modules/json-schema-typed": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/json-schema-typed/-/json-schema-typed-8.0.2.tgz", + "integrity": "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==", + "license": "BSD-2-Clause" }, "node_modules/json-stable-stringify": { "version": "1.3.0", @@ -10275,13 +10179,15 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/json5": { "version": "2.2.3", "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", "dev": true, + "license": "MIT", "bin": { "json5": "lib/cli.js" }, @@ -10317,19 +10223,11 @@ "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", "dev": true, + "license": "MIT", "dependencies": { "json-buffer": "3.0.1" } }, - "node_modules/kind-of": { - "version": "6.0.3", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", - "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/klaw-sync": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/klaw-sync/-/klaw-sync-6.0.0.tgz", @@ -10345,6 +10243,7 @@ "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", "dev": true, + "license": "MIT", "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" @@ -10354,17 +10253,17 @@ } }, "node_modules/liftoff": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/liftoff/-/liftoff-4.0.0.tgz", - "integrity": "sha512-rMGwYF8q7g2XhG2ulBmmJgWv25qBsqRbDn5gH0+wnuyeFt7QBJlHJmtg5qEdn4pN6WVAUMgXnIxytMFRX9c1aA==", + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/liftoff/-/liftoff-5.0.1.tgz", + "integrity": "sha512-wwLXMbuxSF8gMvubFcFRp56lkFV69twvbU5vDPbaw+Q+/rF8j0HKjGbIdlSi+LuJm9jf7k9PB+nTxnsLMPcv2Q==", "dev": true, + "license": "MIT", "dependencies": { "extend": "^3.0.2", "findup-sync": "^5.0.0", "fined": "^2.0.0", "flagged-respawn": "^2.0.0", "is-plain-object": "^5.0.0", - "object.map": "^1.0.1", "rechoir": "^0.8.0", "resolve": "^1.20.0" }, @@ -10372,35 +10271,20 @@ "node": ">=10.13.0" } }, - "node_modules/lilconfig": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz", - "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==", - "dev": true, - "engines": { - "node": ">=14" - }, - "funding": { - "url": "https://github.com/sponsors/antonk52" - } - }, "node_modules/lint-staged": { - "version": "16.1.0", - "resolved": "https://registry.npmjs.org/lint-staged/-/lint-staged-16.1.0.tgz", - "integrity": "sha512-HkpQh69XHxgCjObjejBT3s2ILwNjFx8M3nw+tJ/ssBauDlIpkx2RpqWSi1fBgkXLSSXnbR3iEq1NkVtpvV+FLQ==", + "version": "16.2.7", + "resolved": "https://registry.npmjs.org/lint-staged/-/lint-staged-16.2.7.tgz", + "integrity": "sha512-lDIj4RnYmK7/kXMya+qJsmkRFkGolciXjrsZ6PC25GdTfWOAWetR0ZbsNXRAj1EHHImRSalc+whZFg56F5DVow==", "dev": true, "license": "MIT", "dependencies": { - "chalk": "^5.4.1", - "commander": "^14.0.0", - "debug": "^4.4.1", - "lilconfig": "^3.1.3", - "listr2": "^8.3.3", + "commander": "^14.0.2", + "listr2": "^9.0.5", "micromatch": "^4.0.8", - "nano-spawn": "^1.0.2", + "nano-spawn": "^2.0.0", "pidtree": "^0.6.0", "string-argv": "^0.3.2", - "yaml": "^2.8.0" + "yaml": "^2.8.1" }, "bin": { "lint-staged": "bin/lint-staged.js" @@ -10412,25 +10296,14 @@ "url": "https://opencollective.com/lint-staged" } }, - "node_modules/lint-staged/node_modules/chalk": { - "version": "5.4.1", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz", - "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==", - "dev": true, - "engines": { - "node": "^12.17.0 || ^14.13 || >=16.0.0" - }, - "funding": { - "url": "https://github.com/chalk/chalk?sponsor=1" - } - }, "node_modules/listr2": { - "version": "8.3.3", - "resolved": "https://registry.npmjs.org/listr2/-/listr2-8.3.3.tgz", - "integrity": "sha512-LWzX2KsqcB1wqQ4AHgYb4RsDXauQiqhjLk+6hjbaeHG4zpjjVAB6wC/gz6X0l+Du1cN3pUB5ZlrvTbhGSNnUQQ==", + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/listr2/-/listr2-9.0.5.tgz", + "integrity": "sha512-ME4Fb83LgEgwNw96RKNvKV4VTLuXfoKudAmm2lP8Kk87KaMK0/Xrx/aAkMWmT8mDb+3MlFDspfbCs7adjRxA2g==", "dev": true, + "license": "MIT", "dependencies": { - "cli-truncate": "^4.0.0", + "cli-truncate": "^5.0.0", "colorette": "^2.0.20", "eventemitter3": "^5.0.1", "log-update": "^6.1.0", @@ -10438,7 +10311,7 @@ "wrap-ansi": "^9.0.0" }, "engines": { - "node": ">=18.0.0" + "node": ">=20.0.0" } }, "node_modules/locate-path": { @@ -10446,6 +10319,7 @@ "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", "dev": true, + "license": "MIT", "dependencies": { "p-locate": "^5.0.0" }, @@ -10462,61 +10336,61 @@ "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==", "license": "MIT" }, - "node_modules/lodash.get": { - "version": "4.4.2", - "resolved": "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz", - "integrity": "sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==", - "deprecated": "This package is deprecated. Use the optional chaining (?.) operator instead.", - "dev": true, - "license": "MIT" - }, "node_modules/lodash.merge": { "version": "4.6.2", "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/log-symbols": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-6.0.0.tgz", - "integrity": "sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", + "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", "dev": true, "license": "MIT", "dependencies": { - "chalk": "^5.3.0", - "is-unicode-supported": "^1.3.0" + "chalk": "^4.1.0", + "is-unicode-supported": "^0.1.0" }, "engines": { - "node": ">=18" + "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/log-symbols/node_modules/chalk": { - "version": "5.4.1", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz", - "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==", + "node_modules/log-symbols/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, "engines": { - "node": "^12.17.0 || ^14.13 || >=16.0.0" + "node": ">=8" }, "funding": { - "url": "https://github.com/chalk/chalk?sponsor=1" + "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, - "node_modules/log-symbols/node_modules/is-unicode-supported": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz", - "integrity": "sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==", + "node_modules/log-symbols/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, "engines": { - "node": ">=12" + "node": ">=10" }, "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "url": "https://github.com/chalk/chalk?sponsor=1" } }, "node_modules/log-update": { @@ -10524,6 +10398,7 @@ "resolved": "https://registry.npmjs.org/log-update/-/log-update-6.1.0.tgz", "integrity": "sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==", "dev": true, + "license": "MIT", "dependencies": { "ansi-escapes": "^7.0.0", "cli-cursor": "^5.0.0", @@ -10538,91 +10413,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/log-update/node_modules/ansi-escapes": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.0.0.tgz", - "integrity": "sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==", - "dev": true, - "dependencies": { - "environment": "^1.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/log-update/node_modules/ansi-regex": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", - "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", - "dev": true, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/chalk/ansi-regex?sponsor=1" - } - }, - "node_modules/log-update/node_modules/ansi-styles": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", - "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", - "dev": true, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/chalk/ansi-styles?sponsor=1" - } - }, - "node_modules/log-update/node_modules/is-fullwidth-code-point": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.0.0.tgz", - "integrity": "sha512-OVa3u9kkBbw7b8Xw5F9P+D/T9X+Z4+JruYVNapTjPYZYUznQ5YfWeFkOj606XYYW8yugTfC8Pj0hYqvi4ryAhA==", - "dev": true, - "dependencies": { - "get-east-asian-width": "^1.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/log-update/node_modules/slice-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-7.1.0.tgz", - "integrity": "sha512-bSiSngZ/jWeX93BqeIAbImyTbEihizcwNjFoRUIY/T1wWQsfsm2Vw1agPKylXvQTU7iASGdHhyqRlqQzfz+Htg==", - "dev": true, - "dependencies": { - "ansi-styles": "^6.2.1", - "is-fullwidth-code-point": "^5.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/chalk/slice-ansi?sponsor=1" - } - }, - "node_modules/log-update/node_modules/strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", - "dev": true, - "dependencies": { - "ansi-regex": "^6.0.1" - }, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/chalk/strip-ansi?sponsor=1" - } - }, "node_modules/long": { "version": "5.3.2", "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz", @@ -10636,29 +10426,20 @@ "dev": true, "license": "MIT" }, - "node_modules/lower-case": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz", - "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==", - "dev": true, - "license": "MIT", - "dependencies": { - "tslib": "^2.0.3" - } - }, "node_modules/lru-cache": { "version": "5.1.1", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", "dev": true, + "license": "ISC", "dependencies": { "yallist": "^3.0.2" } }, "node_modules/magic-string": { - "version": "0.30.18", - "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.18.tgz", - "integrity": "sha512-yi8swmWbO17qHhwIBNeeZxTceJMeBvWJaId6dyvTSOwTipqeHhMhOrz6513r1sOKnpvQ7zkhlG8tPrpilwTxHQ==", + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", "dev": true, "license": "MIT", "dependencies": { @@ -10682,6 +10463,7 @@ "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz", "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==", "dev": true, + "license": "MIT", "dependencies": { "semver": "^7.5.3" }, @@ -10692,23 +10474,12 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/make-iterator": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/make-iterator/-/make-iterator-1.0.1.tgz", - "integrity": "sha512-pxiuXh0iVEq7VM7KMIhs5gxsfxCux2URptUQaXo4iZZJxBAzTPOLE2BumO5dbfVYq/hBJFBR/a1mFDmOx5AGmw==", - "dev": true, - "dependencies": { - "kind-of": "^6.0.2" - }, - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/map-cache": { "version": "0.2.2", "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz", "integrity": "sha512-8y/eV9QQZCiyn1SprXSrCmqJN0yNRATe+PO8ztwqrvrbdRLA3eYJF0yaR0YayLWkMbsQSKWS9N2gPcGEc4UsZg==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -10717,6 +10488,7 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", "engines": { "node": ">= 0.4" } @@ -10725,6 +10497,7 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz", "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==", + "license": "MIT", "engines": { "node": ">= 0.8" } @@ -10733,6 +10506,7 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz", "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==", + "license": "MIT", "engines": { "node": ">=18" }, @@ -10740,20 +10514,12 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/merge2": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", - "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", - "dev": true, - "engines": { - "node": ">= 8" - } - }, "node_modules/micromatch": { "version": "4.0.8", "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", "dev": true, + "license": "MIT", "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" @@ -10762,23 +10528,42 @@ "node": ">=8.6" } }, + "node_modules/micromatch/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/mime-db": { "version": "1.54.0", "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz", "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==", + "license": "MIT", "engines": { "node": ">= 0.6" } }, "node_modules/mime-types": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz", - "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz", + "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==", + "license": "MIT", "dependencies": { "mime-db": "^1.54.0" }, "engines": { - "node": ">= 0.6" + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/mimic-fn": { @@ -10786,6 +10571,7 @@ "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", "dev": true, + "license": "MIT", "engines": { "node": ">=6" } @@ -10795,6 +10581,7 @@ "resolved": "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz", "integrity": "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -10807,6 +10594,7 @@ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", "dev": true, + "license": "ISC", "dependencies": { "brace-expansion": "^2.0.1" }, @@ -10822,6 +10610,7 @@ "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", "dev": true, + "license": "MIT", "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -10861,7 +10650,8 @@ "node_modules/ms": { "version": "2.1.3", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" }, "node_modules/mute-stream": { "version": "1.0.0", @@ -10874,9 +10664,9 @@ } }, "node_modules/nano-spawn": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/nano-spawn/-/nano-spawn-1.0.2.tgz", - "integrity": "sha512-21t+ozMQDAL/UGgQVBbZ/xXvNO10++ZPuTmKRO8k9V3AClVRht49ahtDjfY8l1q6nSHOrE5ASfthzH3ol6R/hg==", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/nano-spawn/-/nano-spawn-2.0.0.tgz", + "integrity": "sha512-tacvGzUY5o2D8CBh2rrwxyNojUsZNU2zjNTzKQrkgGJQTbGAfArVWXSKMBokBeeg6C7OLRGUEyoFlYbfeWQIqw==", "dev": true, "license": "MIT", "engines": { @@ -10905,16 +10695,28 @@ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" } }, + "node_modules/nanospinner": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/nanospinner/-/nanospinner-1.2.2.tgz", + "integrity": "sha512-Zt/AmG6qRU3e+WnzGGLuMCEAO/dAu45stNbHY223tUxldaDAeE+FxSPsd9Q+j+paejmm0ZbrNVs5Sraqy3dRxA==", + "dev": true, + "license": "MIT", + "dependencies": { + "picocolors": "^1.1.1" + } + }, "node_modules/natural-compare": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/negotiator": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz", "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==", + "license": "MIT", "engines": { "node": ">= 0.6" } @@ -10926,17 +10728,6 @@ "dev": true, "license": "MIT" }, - "node_modules/no-case": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz", - "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==", - "dev": true, - "license": "MIT", - "dependencies": { - "lower-case": "^2.0.2", - "tslib": "^2.0.3" - } - }, "node_modules/node-fetch": { "version": "2.7.0", "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", @@ -10958,49 +10749,39 @@ } }, "node_modules/node-plop": { - "version": "0.32.0", - "resolved": "https://registry.npmjs.org/node-plop/-/node-plop-0.32.0.tgz", - "integrity": "sha512-lKFSRSRuDHhwDKMUobdsvaWCbbDRbV3jMUSMiajQSQux1aNUevAZVxUHc2JERI//W8ABPRbi3ebYuSuIzkNIpQ==", + "version": "0.32.3", + "resolved": "https://registry.npmjs.org/node-plop/-/node-plop-0.32.3.tgz", + "integrity": "sha512-tn+OxutdqhvoByKJ7p84FZBSUDfUB76bcvj0ugLBvgE9V52LFcnz8cauCDKi6otnctvFCqa9XkrU35pBY5Baig==", "dev": true, "license": "MIT", "dependencies": { - "@types/inquirer": "^9.0.3", - "change-case": "^4.1.2", - "del": "^7.1.0", - "globby": "^13.2.2", + "@types/inquirer": "^9.0.9", + "@types/picomatch": "^4.0.2", + "change-case": "^5.4.4", + "dlv": "^1.1.3", "handlebars": "^4.7.8", - "inquirer": "^9.2.10", - "isbinaryfile": "^5.0.0", - "lodash.get": "^4.4.2", - "lower-case": "^2.0.2", - "mkdirp": "^3.0.1", - "resolve": "^1.22.4", - "title-case": "^3.0.3", - "upper-case": "^2.0.2" + "inquirer": "^9.3.8", + "isbinaryfile": "^5.0.6", + "resolve": "^1.22.10", + "tinyglobby": "^0.2.15", + "title-case": "^4.3.2" }, "engines": { - "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + "node": ">=18" } }, "node_modules/node-releases": { - "version": "2.0.19", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz", - "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==", - "dev": true - }, - "node_modules/normalize-path": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", - "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "version": "2.0.27", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz", + "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==", "dev": true, - "engines": { - "node": ">=0.10.0" - } + "license": "MIT" }, "node_modules/object-assign": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -11009,6 +10790,7 @@ "version": "1.13.4", "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -11031,6 +10813,7 @@ "resolved": "https://registry.npmjs.org/object.defaults/-/object.defaults-1.1.0.tgz", "integrity": "sha512-c/K0mw/F11k4dEUBMW8naXUuBuhxRCfG7W+yFy8EcijU/rSmazOUd1XAEEe6bC0OuXY4HUKjTJv7xbxIMqdxrA==", "dev": true, + "license": "MIT", "dependencies": { "array-each": "^1.0.1", "array-slice": "^1.0.0", @@ -11041,24 +10824,12 @@ "node": ">=0.10.0" } }, - "node_modules/object.map": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/object.map/-/object.map-1.0.1.tgz", - "integrity": "sha512-3+mAJu2PLfnSVGHwIWubpOFLscJANBKuB/6A4CxBstc4aqwQY0FWcsppuy4jU5GSB95yES5JHSI+33AWuS4k6w==", - "dev": true, - "dependencies": { - "for-own": "^1.0.0", - "make-iterator": "^1.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/object.pick": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz", "integrity": "sha512-tqa/UMy/CCoYmj+H5qc07qvSL9dqcs/WZENZ1JbtWBlATP+iVOe778gE6MSijnyCnORzDuX6hU+LA4SZ09YjFQ==", "dev": true, + "license": "MIT", "dependencies": { "isobject": "^3.0.1" }, @@ -11070,6 +10841,7 @@ "version": "2.4.1", "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", "dependencies": { "ee-first": "1.1.1" }, @@ -11081,20 +10853,22 @@ "version": "1.4.0", "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", "dependencies": { "wrappy": "1" } }, "node_modules/onetime": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", - "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz", + "integrity": "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==", "dev": true, + "license": "MIT", "dependencies": { - "mimic-fn": "^2.1.0" + "mimic-function": "^5.0.0" }, "engines": { - "node": ">=6" + "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" @@ -11122,6 +10896,7 @@ "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", "dev": true, + "license": "MIT", "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", @@ -11135,103 +10910,143 @@ } }, "node_modules/ora": { - "version": "8.2.0", - "resolved": "https://registry.npmjs.org/ora/-/ora-8.2.0.tgz", - "integrity": "sha512-weP+BZ8MVNnlCm8c0Qdc1WSWq4Qn7I+9CJGm7Qali6g44e/PUzbjNqJX5NJ9ljlNMosfJvg1fKEGILklK9cwnw==", + "version": "5.4.1", + "resolved": "https://registry.npmjs.org/ora/-/ora-5.4.1.tgz", + "integrity": "sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==", "dev": true, "license": "MIT", "dependencies": { - "chalk": "^5.3.0", - "cli-cursor": "^5.0.0", - "cli-spinners": "^2.9.2", - "is-interactive": "^2.0.0", - "is-unicode-supported": "^2.0.0", - "log-symbols": "^6.0.0", - "stdin-discarder": "^0.2.2", - "string-width": "^7.2.0", - "strip-ansi": "^7.1.0" + "bl": "^4.1.0", + "chalk": "^4.1.0", + "cli-cursor": "^3.1.0", + "cli-spinners": "^2.5.0", + "is-interactive": "^1.0.0", + "is-unicode-supported": "^0.1.0", + "log-symbols": "^4.1.0", + "strip-ansi": "^6.0.0", + "wcwidth": "^1.0.1" }, "engines": { - "node": ">=18" + "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/ora/node_modules/ansi-regex": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", - "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, "license": "MIT", "engines": { - "node": ">=12" + "node": ">=8" + } + }, + "node_modules/ora/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" }, "funding": { - "url": "https://github.com/chalk/ansi-regex?sponsor=1" + "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, "node_modules/ora/node_modules/chalk": { - "version": "5.4.1", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz", - "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==", + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, "engines": { - "node": "^12.17.0 || ^14.13 || >=16.0.0" + "node": ">=10" }, "funding": { "url": "https://github.com/chalk/chalk?sponsor=1" } }, - "node_modules/ora/node_modules/strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "node_modules/ora/node_modules/cli-cursor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz", + "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==", "dev": true, "license": "MIT", "dependencies": { - "ansi-regex": "^6.0.1" + "restore-cursor": "^3.1.0" }, "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/chalk/strip-ansi?sponsor=1" + "node": ">=8" } }, - "node_modules/os-tmpdir": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", - "integrity": "sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==", + "node_modules/ora/node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", "dev": true, "license": "MIT", + "dependencies": { + "mimic-fn": "^2.1.0" + }, "engines": { - "node": ">=0.10.0" + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/p-limit": { + "node_modules/ora/node_modules/restore-cursor": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", - "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz", + "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==", "dev": true, + "license": "MIT", "dependencies": { - "yocto-queue": "^0.1.0" + "onetime": "^5.1.0", + "signal-exit": "^3.0.2" }, "engines": { - "node": ">=10" + "node": ">=8" + } + }, + "node_modules/ora/node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/ora/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "engines": { + "node": ">=8" } }, - "node_modules/p-locate": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", - "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", "dev": true, + "license": "MIT", "dependencies": { - "p-limit": "^3.0.2" + "yocto-queue": "^0.1.0" }, "engines": { "node": ">=10" @@ -11240,17 +11055,17 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/p-map": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/p-map/-/p-map-5.5.0.tgz", - "integrity": "sha512-VFqfGDHlx87K66yZrNdI4YGtD70IRyd+zSvgks6mzHPRNkoKy+9EKP4SFC77/vTTQYmRmti7dvqC+m5jBrBAcg==", + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", "dev": true, "license": "MIT", "dependencies": { - "aggregate-error": "^4.0.0" + "p-limit": "^3.0.2" }, "engines": { - "node": ">=12" + "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" @@ -11263,27 +11078,17 @@ "dev": true, "license": "BlueOak-1.0.0" }, - "node_modules/param-case": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/param-case/-/param-case-3.0.4.tgz", - "integrity": "sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==", - "dev": true, - "license": "MIT", - "dependencies": { - "dot-case": "^3.0.4", - "tslib": "^2.0.3" - } - }, "node_modules/parent-module": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", - "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-2.0.0.tgz", + "integrity": "sha512-uo0Z9JJeWzv8BG+tRcapBKNJ0dro9cLyczGzulS6EfeyAdeC9sbojtW6XwvYxJkEne9En+J2XEl4zyglVeIwFg==", "dev": true, + "license": "MIT", "dependencies": { - "callsites": "^3.0.0" + "callsites": "^3.1.0" }, "engines": { - "node": ">=6" + "node": ">=8" } }, "node_modules/parse-filepath": { @@ -11291,6 +11096,7 @@ "resolved": "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.2.tgz", "integrity": "sha512-FwdRXKCohSVeXqwtYonZTXtbGJKrn+HNyWDYVcp5yuJlesTwNH4rsmRZ+GrKAPJ5bLpRxESMeS+Rl0VCHRvB2Q==", "dev": true, + "license": "MIT", "dependencies": { "is-absolute": "^1.0.0", "map-cache": "^0.2.0", @@ -11305,6 +11111,7 @@ "resolved": "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz", "integrity": "sha512-1Y1A//QUXEZK7YKz+rD9WydcE1+EuPr6ZBgKecAB8tmoW6UFv0NREVJe1p+jRxtThkcbbKkfwIbWJe/IeE6m2Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -11313,21 +11120,11 @@ "version": "1.3.3", "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "license": "MIT", "engines": { "node": ">= 0.8" } }, - "node_modules/pascal-case": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/pascal-case/-/pascal-case-3.1.2.tgz", - "integrity": "sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==", - "dev": true, - "license": "MIT", - "dependencies": { - "no-case": "^3.0.4", - "tslib": "^2.0.3" - } - }, "node_modules/patch-package": { "version": "8.0.1", "resolved": "https://registry.npmjs.org/patch-package/-/patch-package-8.0.1.tgz", @@ -11358,25 +11155,37 @@ "npm": ">5" } }, - "node_modules/patch-package/node_modules/tmp": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz", - "integrity": "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==", + "node_modules/patch-package/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, "engines": { - "node": ">=14.14" + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, - "node_modules/path-case": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/path-case/-/path-case-3.0.4.tgz", - "integrity": "sha512-qO4qCFjXqVTrcbPt/hQfhTQ+VhFsqNKOPtytgNKkKxSoEp3XPUQ8ObFuePylOIok5gjn69ry8XiULxCwot3Wfg==", + "node_modules/patch-package/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, "license": "MIT", "dependencies": { - "dot-case": "^3.0.4", - "tslib": "^2.0.3" + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" } }, "node_modules/path-exists": { @@ -11384,23 +11193,16 @@ "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, - "node_modules/path-is-absolute": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", - "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/path-key": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "license": "MIT", "engines": { "node": ">=8" } @@ -11408,13 +11210,15 @@ "node_modules/path-parse": { "version": "1.0.7", "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", - "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==" + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "license": "MIT" }, "node_modules/path-root": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/path-root/-/path-root-0.1.1.tgz", "integrity": "sha512-QLcPegTHF11axjfojBIoDygmS2E3Lf+8+jI6wOVmNVenrKSo3mFdSGiIgdSHenczw3wPtlVMQaFVwGmM7BJdtg==", "dev": true, + "license": "MIT", "dependencies": { "path-root-regex": "^0.1.0" }, @@ -11427,53 +11231,43 @@ "resolved": "https://registry.npmjs.org/path-root-regex/-/path-root-regex-0.1.2.tgz", "integrity": "sha512-4GlJ6rZDhQZFE0DPVKh0e9jmZ5egZfxTkp7bcRDuPlJXbAwhxcl2dINPUAsjLdejqaLsCeg8axcLjIbvBjN4pQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/path-scurry": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.0.tgz", - "integrity": "sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg==", + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", + "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { - "lru-cache": "^11.0.0", - "minipass": "^7.1.2" + "lru-cache": "^10.2.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" }, "engines": { - "node": "20 || >=22" + "node": ">=16 || 14 >=14.18" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/path-scurry/node_modules/lru-cache": { - "version": "11.1.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.1.0.tgz", - "integrity": "sha512-QIXZUBJUx+2zHUdQujWejBkcD9+cs94tLn0+YL8UrCh+D5sCXZ4c7LaEH48pNwRY3MLDgqUFyhlCyjJPf1WP0A==", + "version": "10.4.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz", + "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==", "dev": true, - "license": "ISC", - "engines": { - "node": "20 || >=22" - } + "license": "ISC" }, "node_modules/path-to-regexp": { - "version": "8.2.0", - "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.2.0.tgz", - "integrity": "sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==", - "engines": { - "node": ">=16" - } - }, - "node_modules/path-type": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", - "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", - "dev": true, + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.3.0.tgz", + "integrity": "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==", "license": "MIT", - "engines": { - "node": ">=8" + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/pathe": { @@ -11528,15 +11322,17 @@ "version": "1.1.1", "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", - "dev": true + "dev": true, + "license": "ISC" }, "node_modules/picomatch": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", - "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", + "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", "dev": true, + "license": "MIT", "engines": { - "node": ">=8.6" + "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/jonschlinkert" @@ -11547,6 +11343,7 @@ "resolved": "https://registry.npmjs.org/pidtree/-/pidtree-0.6.0.tgz", "integrity": "sha512-eG2dWTVw5bzqGRztnHExczNxt5VGsE6OwTeCG3fdUf9KBsZzO3R5OIIIzWR+iZA0NtZ+RDVdaoE2dK1cn6jH4g==", "dev": true, + "license": "MIT", "bin": { "pidtree": "bin/pidtree.js" }, @@ -11555,27 +11352,28 @@ } }, "node_modules/pkce-challenge": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.0.tgz", - "integrity": "sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ==", + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.1.tgz", + "integrity": "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==", + "license": "MIT", "engines": { "node": ">=16.20.0" } }, "node_modules/plop": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/plop/-/plop-4.0.1.tgz", - "integrity": "sha512-5n8QU93kvL/ObOzBcPAB1siVFtAH1TZM6TntJ3JK5kXT0jIgnQV+j+uaOWWFJlg1cNkzLYm8klgASF65K36q9w==", + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/plop/-/plop-4.0.4.tgz", + "integrity": "sha512-YdxtHWcPV8hDsszVPr4VQBVGNdn5ZQmEW+cZakZkuVeQHtENmrtY4AhuyoZW6s7ZjpmrS+llLQrfDgRKNQNsmg==", "dev": true, "license": "MIT", "dependencies": { "@types/liftoff": "^4.0.3", - "chalk": "^5.3.0", "interpret": "^3.1.1", - "liftoff": "^4.0.0", + "liftoff": "^5.0.1", "minimist": "^1.2.8", - "node-plop": "^0.32.0", - "ora": "^8.0.0", + "nanospinner": "^1.2.2", + "node-plop": "^0.32.3", + "picocolors": "^1.1.1", "v8flags": "^4.0.1" }, "bin": { @@ -11585,18 +11383,6 @@ "node": ">=18" } }, - "node_modules/plop/node_modules/chalk": { - "version": "5.4.1", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz", - "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==", - "dev": true, - "engines": { - "node": "^12.17.0 || ^14.13 || >=16.0.0" - }, - "funding": { - "url": "https://github.com/chalk/chalk?sponsor=1" - } - }, "node_modules/polite-json": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/polite-json/-/polite-json-5.0.0.tgz", @@ -11649,9 +11435,9 @@ } }, "node_modules/postgres-bytea": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.0.tgz", - "integrity": "sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w==", + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.1.tgz", + "integrity": "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==", "license": "MIT", "engines": { "node": ">=0.10.0" @@ -11683,15 +11469,16 @@ "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", "dev": true, + "license": "MIT", "engines": { "node": ">= 0.8.0" } }, "node_modules/prettier": { - "version": "3.5.3", - "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.5.3.tgz", - "integrity": "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==", - "dev": true, + "version": "3.7.4", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.7.4.tgz", + "integrity": "sha512-v6UNi1+3hSlVvv8fSaoUbggEM5VErKmmpGA7Pl3HF8V6uKY7rvClBOJlH6yNwQtfTueNkGVpOv/mtWL9L4bgRA==", + "license": "MIT", "bin": { "prettier": "bin/prettier.cjs" }, @@ -11703,9 +11490,9 @@ } }, "node_modules/prettier-linter-helpers": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz", - "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==", + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.1.tgz", + "integrity": "sha512-SxToR7P8Y2lWmv/kTzVLC1t/GDI2WGjMwNhLLE9qtH8Q13C+aEmuRlzDst4Up4s0Wc8sF2M+J57iB3cMLqftfg==", "dev": true, "license": "MIT", "dependencies": { @@ -11743,6 +11530,7 @@ "version": "2.0.7", "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "license": "MIT", "dependencies": { "forwarded": "0.2.0", "ipaddr.js": "1.9.1" @@ -11756,14 +11544,16 @@ "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", "dev": true, + "license": "MIT", "engines": { "node": ">=6" } }, "node_modules/qs": { - "version": "6.14.0", - "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz", - "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==", + "version": "6.14.1", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz", + "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==", + "license": "BSD-3-Clause", "dependencies": { "side-channel": "^1.1.0" }, @@ -11774,46 +11564,28 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/queue-microtask": { - "version": "1.2.3", - "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", - "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", - "dev": true, - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/feross" - }, - { - "type": "patreon", - "url": "https://www.patreon.com/feross" - }, - { - "type": "consulting", - "url": "https://feross.org/support" - } - ] - }, "node_modules/range-parser": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "license": "MIT", "engines": { "node": ">= 0.6" } }, "node_modules/raw-body": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz", - "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz", + "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==", + "license": "MIT", "dependencies": { - "bytes": "3.1.2", - "http-errors": "2.0.0", - "iconv-lite": "0.6.3", - "unpipe": "1.0.0" + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.7.0", + "unpipe": "~1.0.0" }, "engines": { - "node": ">= 0.8" + "node": ">= 0.10" } }, "node_modules/readable-stream": { @@ -11832,16 +11604,17 @@ } }, "node_modules/readdirp": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", - "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz", + "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==", "dev": true, "license": "MIT", - "dependencies": { - "picomatch": "^2.2.1" - }, "engines": { - "node": ">=8.10.0" + "node": ">= 14.18.0" + }, + "funding": { + "type": "individual", + "url": "https://paulmillr.com/funding/" } }, "node_modules/rechoir": { @@ -11849,6 +11622,7 @@ "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.8.0.tgz", "integrity": "sha512-/vxpCXddiX8NGfGO/mTafwjq4aFa/71pvamip0++IQk3zG8cbCj0fifNPrjjF1XMXUne91jL9OoxmdykoEtifQ==", "dev": true, + "license": "MIT", "dependencies": { "resolve": "^1.20.0" }, @@ -11889,11 +11663,12 @@ } }, "node_modules/resolve": { - "version": "1.22.10", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz", - "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==", + "version": "1.22.11", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz", + "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==", + "license": "MIT", "dependencies": { - "is-core-module": "^2.16.0", + "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, @@ -11912,6 +11687,7 @@ "resolved": "https://registry.npmjs.org/resolve-dir/-/resolve-dir-1.0.1.tgz", "integrity": "sha512-R7uiTjECzvOsWSfdM0QKFNBVFcK27aHOUwdvK53BcW8zqnGdYp0Fbj82cy54+2A4P2tFM22J5kRfe1R+lM/1yg==", "dev": true, + "license": "MIT", "dependencies": { "expand-tilde": "^2.0.0", "global-modules": "^1.0.0" @@ -11921,22 +11697,23 @@ } }, "node_modules/resolve-from": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", - "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", "dev": true, + "license": "MIT", "engines": { - "node": ">=4" + "node": ">=8" } }, "node_modules/resolve-import": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/resolve-import/-/resolve-import-2.0.0.tgz", - "integrity": "sha512-jpKjLibLuc8D1XEV2+7zb0aqN7I8d12u89g/v6IsgCzdVlccMQJq4TKkPw5fbhHdxhm7nbVtN+KvOTnjFf+nEA==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/resolve-import/-/resolve-import-2.1.1.tgz", + "integrity": "sha512-pgTo41KMWjSZNNA4Ptgs+AtB+/w+a2/MDm6VzZiEnt2op2rXHYK/EYdRYhBsPlGN1naYMogJopBoJxtHgGTHEA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { - "glob": "^11.0.0", + "glob": "^13.0.0", "walk-up-path": "^4.0.0" }, "engines": { @@ -11947,22 +11724,16 @@ } }, "node_modules/resolve-import/node_modules/glob": { - "version": "11.0.3", - "resolved": "https://registry.npmjs.org/glob/-/glob-11.0.3.tgz", - "integrity": "sha512-2Nim7dha1KVkaiF4q6Dj+ngPPMdfvLJEOpZk/jKiUAkqKebpGAWQXAq9z1xu9HKu5lWfqw/FASuccEjyznjPaA==", + "version": "13.0.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.0.tgz", + "integrity": "sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==", "dev": true, - "license": "ISC", + "license": "BlueOak-1.0.0", "dependencies": { - "foreground-child": "^3.3.1", - "jackspeak": "^4.1.1", - "minimatch": "^10.0.3", + "minimatch": "^10.1.1", "minipass": "^7.1.2", - "package-json-from-dist": "^1.0.0", "path-scurry": "^2.0.0" }, - "bin": { - "glob": "dist/esm/bin.mjs" - }, "engines": { "node": "20 || >=22" }, @@ -11970,12 +11741,22 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/resolve-import/node_modules/lru-cache": { + "version": "11.2.4", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.4.tgz", + "integrity": "sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, "node_modules/resolve-import/node_modules/minimatch": { - "version": "10.0.3", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.0.3.tgz", - "integrity": "sha512-IPZ167aShDZZUMdRk66cyQAW3qr0WzbHkPdMYa8bzZhlHhO3jALbKdxcaak7W9FfT2rZNpQuUu4Od7ILEpXSaw==", + "version": "10.1.1", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.1.1.tgz", + "integrity": "sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==", "dev": true, - "license": "ISC", + "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/brace-expansion": "^5.0.0" }, @@ -11986,6 +11767,23 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/resolve-import/node_modules/path-scurry": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.1.tgz", + "integrity": "sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/resolve-pkg-maps": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", @@ -12001,6 +11799,7 @@ "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz", "integrity": "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==", "dev": true, + "license": "MIT", "dependencies": { "onetime": "^7.0.0", "signal-exit": "^4.1.0" @@ -12012,70 +11811,98 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/restore-cursor/node_modules/onetime": { - "version": "7.0.0", - "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz", - "integrity": "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==", + "node_modules/rfdc": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz", + "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==", + "dev": true, + "license": "MIT" + }, + "node_modules/rimraf": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-6.1.2.tgz", + "integrity": "sha512-cFCkPslJv7BAXJsYlK1dZsbP8/ZNLkCAQ0bi1hf5EKX2QHegmDFEFA6QhuYJlk7UDdc+02JjO80YSOrWPpw06g==", "dev": true, + "license": "BlueOak-1.0.0", "dependencies": { - "mimic-function": "^5.0.0" + "glob": "^13.0.0", + "package-json-from-dist": "^1.0.1" + }, + "bin": { + "rimraf": "dist/esm/bin.mjs" }, "engines": { - "node": ">=18" + "node": "20 || >=22" }, "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/restore-cursor/node_modules/signal-exit": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", - "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "node_modules/rimraf/node_modules/glob": { + "version": "13.0.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.0.tgz", + "integrity": "sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==", "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "minimatch": "^10.1.1", + "minipass": "^7.1.2", + "path-scurry": "^2.0.0" + }, "engines": { - "node": ">=14" + "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/reusify": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", - "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", + "node_modules/rimraf/node_modules/lru-cache": { + "version": "11.2.4", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.4.tgz", + "integrity": "sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==", "dev": true, + "license": "BlueOak-1.0.0", "engines": { - "iojs": ">=1.0.0", - "node": ">=0.10.0" + "node": "20 || >=22" + } + }, + "node_modules/rimraf/node_modules/minimatch": { + "version": "10.1.1", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.1.1.tgz", + "integrity": "sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/brace-expansion": "^5.0.0" + }, + "engines": { + "node": "20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/rfdc": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz", - "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==", - "dev": true - }, - "node_modules/rimraf": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", - "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", - "deprecated": "Rimraf versions prior to v4 are no longer supported", + "node_modules/rimraf/node_modules/path-scurry": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.1.tgz", + "integrity": "sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==", "dev": true, - "license": "ISC", + "license": "BlueOak-1.0.0", "dependencies": { - "glob": "^7.1.3" + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" }, - "bin": { - "rimraf": "bin.js" + "engines": { + "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/rollup": { - "version": "4.50.0", - "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.50.0.tgz", - "integrity": "sha512-/Zl4D8zPifNmyGzJS+3kVoyXeDeT/GrsJM94sACNg9RtUE0hrHa1bNPtRSrfHTMH5HjRzce6K7rlTh3Khiw+pw==", + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.55.1.tgz", + "integrity": "sha512-wDv/Ht1BNHB4upNbK74s9usvl7hObDnvVzknxqY/E/O3X6rW1U1rV1aENEfJ54eFZDTNo7zv1f5N4edCluH7+A==", "dev": true, "license": "MIT", "dependencies": { @@ -12089,27 +11916,31 @@ "npm": ">=8.0.0" }, "optionalDependencies": { - "@rollup/rollup-android-arm-eabi": "4.50.0", - "@rollup/rollup-android-arm64": "4.50.0", - "@rollup/rollup-darwin-arm64": "4.50.0", - "@rollup/rollup-darwin-x64": "4.50.0", - "@rollup/rollup-freebsd-arm64": "4.50.0", - "@rollup/rollup-freebsd-x64": "4.50.0", - "@rollup/rollup-linux-arm-gnueabihf": "4.50.0", - "@rollup/rollup-linux-arm-musleabihf": "4.50.0", - "@rollup/rollup-linux-arm64-gnu": "4.50.0", - "@rollup/rollup-linux-arm64-musl": "4.50.0", - "@rollup/rollup-linux-loongarch64-gnu": "4.50.0", - "@rollup/rollup-linux-ppc64-gnu": "4.50.0", - "@rollup/rollup-linux-riscv64-gnu": "4.50.0", - "@rollup/rollup-linux-riscv64-musl": "4.50.0", - "@rollup/rollup-linux-s390x-gnu": "4.50.0", - "@rollup/rollup-linux-x64-gnu": "4.50.0", - "@rollup/rollup-linux-x64-musl": "4.50.0", - "@rollup/rollup-openharmony-arm64": "4.50.0", - "@rollup/rollup-win32-arm64-msvc": "4.50.0", - "@rollup/rollup-win32-ia32-msvc": "4.50.0", - "@rollup/rollup-win32-x64-msvc": "4.50.0", + "@rollup/rollup-android-arm-eabi": "4.55.1", + "@rollup/rollup-android-arm64": "4.55.1", + "@rollup/rollup-darwin-arm64": "4.55.1", + "@rollup/rollup-darwin-x64": "4.55.1", + "@rollup/rollup-freebsd-arm64": "4.55.1", + "@rollup/rollup-freebsd-x64": "4.55.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.55.1", + "@rollup/rollup-linux-arm-musleabihf": "4.55.1", + "@rollup/rollup-linux-arm64-gnu": "4.55.1", + "@rollup/rollup-linux-arm64-musl": "4.55.1", + "@rollup/rollup-linux-loong64-gnu": "4.55.1", + "@rollup/rollup-linux-loong64-musl": "4.55.1", + "@rollup/rollup-linux-ppc64-gnu": "4.55.1", + "@rollup/rollup-linux-ppc64-musl": "4.55.1", + "@rollup/rollup-linux-riscv64-gnu": "4.55.1", + "@rollup/rollup-linux-riscv64-musl": "4.55.1", + "@rollup/rollup-linux-s390x-gnu": "4.55.1", + "@rollup/rollup-linux-x64-gnu": "4.55.1", + "@rollup/rollup-linux-x64-musl": "4.55.1", + "@rollup/rollup-openbsd-x64": "4.55.1", + "@rollup/rollup-openharmony-arm64": "4.55.1", + "@rollup/rollup-win32-arm64-msvc": "4.55.1", + "@rollup/rollup-win32-ia32-msvc": "4.55.1", + "@rollup/rollup-win32-x64-gnu": "4.55.1", + "@rollup/rollup-win32-x64-msvc": "4.55.1", "fsevents": "~2.3.2" } }, @@ -12117,6 +11948,7 @@ "version": "2.2.0", "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz", "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==", + "license": "MIT", "dependencies": { "debug": "^4.4.0", "depd": "^2.0.0", @@ -12138,29 +11970,6 @@ "node": ">=0.12.0" } }, - "node_modules/run-parallel": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", - "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", - "dev": true, - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/feross" - }, - { - "type": "patreon", - "url": "https://www.patreon.com/feross" - }, - { - "type": "consulting", - "url": "https://feross.org/support" - } - ], - "dependencies": { - "queue-microtask": "^1.2.2" - } - }, "node_modules/rxjs": { "version": "7.8.2", "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz", @@ -12175,6 +11984,7 @@ "version": "5.2.1", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "dev": true, "funding": [ { "type": "github", @@ -12188,17 +11998,20 @@ "type": "consulting", "url": "https://feross.org/support" } - ] + ], + "license": "MIT" }, "node_modules/safer-buffer": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", - "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" }, "node_modules/semver": { - "version": "7.7.2", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", - "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "version": "7.7.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", + "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", + "license": "ISC", "bin": { "semver": "bin/semver.js" }, @@ -12207,42 +12020,36 @@ } }, "node_modules/send": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz", - "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/send/-/send-1.2.1.tgz", + "integrity": "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==", + "license": "MIT", "dependencies": { - "debug": "^4.3.5", + "debug": "^4.4.3", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "fresh": "^2.0.0", - "http-errors": "^2.0.0", - "mime-types": "^3.0.1", + "http-errors": "^2.0.1", + "mime-types": "^3.0.2", "ms": "^2.1.3", "on-finished": "^2.4.1", "range-parser": "^1.2.1", - "statuses": "^2.0.1" + "statuses": "^2.0.2" }, "engines": { "node": ">= 18" - } - }, - "node_modules/sentence-case": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/sentence-case/-/sentence-case-3.0.4.tgz", - "integrity": "sha512-8LS0JInaQMCRoQ7YUytAo/xUu5W2XnQxV2HI/6uM6U7CITS1RqPElr30V6uIqyMKM9lJGRVFy5/4CuzcixNYSg==", - "dev": true, - "license": "MIT", - "dependencies": { - "no-case": "^3.0.4", - "tslib": "^2.0.3", - "upper-case-first": "^2.0.2" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/serve-static": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz", - "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==", + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.1.tgz", + "integrity": "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==", + "license": "MIT", "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", @@ -12251,6 +12058,10 @@ }, "engines": { "node": ">= 18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/set-function-length": { @@ -12274,12 +12085,14 @@ "node_modules/setprototypeof": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", - "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==" + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" }, "node_modules/shebang-command": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "license": "MIT", "dependencies": { "shebang-regex": "^3.0.0" }, @@ -12291,6 +12104,7 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "license": "MIT", "engines": { "node": ">=8" } @@ -12305,6 +12119,7 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "license": "MIT", "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3", @@ -12323,6 +12138,7 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "license": "MIT", "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3" @@ -12338,6 +12154,7 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "license": "MIT", "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", @@ -12355,6 +12172,7 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "license": "MIT", "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", @@ -12377,10 +12195,17 @@ "license": "ISC" }, "node_modules/signal-exit": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", - "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", - "dev": true + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } }, "node_modules/slash": { "version": "2.0.0", @@ -12393,37 +12218,26 @@ } }, "node_modules/slice-ansi": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-5.0.0.tgz", - "integrity": "sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==", + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-7.1.2.tgz", + "integrity": "sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==", "dev": true, + "license": "MIT", "dependencies": { - "ansi-styles": "^6.0.0", - "is-fullwidth-code-point": "^4.0.0" + "ansi-styles": "^6.2.1", + "is-fullwidth-code-point": "^5.0.0" }, "engines": { - "node": ">=12" + "node": ">=18" }, "funding": { "url": "https://github.com/chalk/slice-ansi?sponsor=1" } }, - "node_modules/slice-ansi/node_modules/ansi-styles": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", - "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", - "dev": true, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/chalk/ansi-styles?sponsor=1" - } - }, "node_modules/smol-toml": { - "version": "1.4.2", - "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.4.2.tgz", - "integrity": "sha512-rInDH6lCNiEyn3+hH8KVGFdbjc099j47+OSgbMrfDYX1CmXLfdKd7qi6IfcWj2wFxvSVkuI46M+wPGYfEOEj6g==", + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.6.0.tgz", + "integrity": "sha512-4zemZi0HvTnYwLfrpk/CF9LOd9Lt87kAt50GnqhMpyF9U3poDAP2+iukq2bZsO/ufegbYehBkqINbsWxj4l4cw==", "dev": true, "license": "BSD-3-Clause", "engines": { @@ -12433,22 +12247,12 @@ "url": "https://github.com/sponsors/cyyynthia" } }, - "node_modules/snake-case": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/snake-case/-/snake-case-3.0.4.tgz", - "integrity": "sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==", - "dev": true, - "license": "MIT", - "dependencies": { - "dot-case": "^3.0.4", - "tslib": "^2.0.3" - } - }, "node_modules/source-map": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", "dev": true, + "license": "BSD-3-Clause", "engines": { "node": ">=0.10.0" } @@ -12471,33 +12275,21 @@ "license": "MIT" }, "node_modules/statuses": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", - "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "license": "MIT", "engines": { "node": ">= 0.8" } }, "node_modules/std-env": { - "version": "3.9.0", - "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.9.0.tgz", - "integrity": "sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw==", + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz", + "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==", "dev": true, "license": "MIT" }, - "node_modules/stdin-discarder": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.2.2.tgz", - "integrity": "sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/string_decoder": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", @@ -12513,22 +12305,23 @@ "resolved": "https://registry.npmjs.org/string-argv/-/string-argv-0.3.2.tgz", "integrity": "sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.6.19" } }, "node_modules/string-width": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz", - "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==", + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-8.1.0.tgz", + "integrity": "sha512-Kxl3KJGb/gxkaUMOjRsQ8IrXiGW75O4E3RPjFIINOVH8AMl2SQ/yWdTzWwF3FevIX9LcMAjJW+GRwAlAbTSXdg==", "dev": true, + "license": "MIT", "dependencies": { - "emoji-regex": "^10.3.0", - "get-east-asian-width": "^1.0.0", + "get-east-asian-width": "^1.3.0", "strip-ansi": "^7.1.0" }, "engines": { - "node": ">=18" + "node": ">=20" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" @@ -12550,12 +12343,15 @@ "node": ">=8" } }, - "node_modules/string-width-cjs/node_modules/emoji-regex": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "node_modules/string-width-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, - "license": "MIT" + "license": "MIT", + "engines": { + "node": ">=8" + } }, "node_modules/string-width-cjs/node_modules/is-fullwidth-code-point": { "version": "3.0.0", @@ -12567,23 +12363,25 @@ "node": ">=8" } }, - "node_modules/string-width/node_modules/ansi-regex": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", - "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "node_modules/string-width-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, - "engines": { - "node": ">=12" + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" }, - "funding": { - "url": "https://github.com/chalk/ansi-regex?sponsor=1" + "engines": { + "node": ">=8" } }, - "node_modules/string-width/node_modules/strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "node_modules/strip-ansi": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz", + "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==", "dev": true, + "license": "MIT", "dependencies": { "ansi-regex": "^6.0.1" }, @@ -12594,10 +12392,13 @@ "url": "https://github.com/chalk/strip-ansi?sponsor=1" } }, - "node_modules/strip-ansi": { + "node_modules/strip-ansi-cjs": { + "name": "strip-ansi", "version": "6.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, @@ -12605,16 +12406,12 @@ "node": ">=8" } }, - "node_modules/strip-ansi-cjs": { - "name": "strip-ansi", - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "node_modules/strip-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, "license": "MIT", - "dependencies": { - "ansi-regex": "^5.0.1" - }, "engines": { "node": ">=8" } @@ -12624,6 +12421,7 @@ "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" }, @@ -12632,9 +12430,9 @@ } }, "node_modules/strip-literal": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.0.0.tgz", - "integrity": "sha512-TcccoMhJOM3OebGhSBEmp3UZ2SfDMZUEBdRA/9ynfLi8yYajyWX3JiXArcJt4Umh4vISpspkQIY8ZZoCqjbviA==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.1.0.tgz", + "integrity": "sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==", "dev": true, "license": "MIT", "dependencies": { @@ -12656,6 +12454,7 @@ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, + "license": "MIT", "dependencies": { "has-flag": "^4.0.0" }, @@ -12667,6 +12466,7 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -12675,17 +12475,17 @@ } }, "node_modules/sync-content": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/sync-content/-/sync-content-2.0.1.tgz", - "integrity": "sha512-NI1mo514yFhr8pV/5Etvgh+pSBUIpoAKoiBIUwALVlQQNAwb40bTw8hhPFaip/dvv0GhpHVOq0vq8iY02ppLTg==", + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/sync-content/-/sync-content-2.0.3.tgz", + "integrity": "sha512-gKE1q9t4qBDkWqJElji6HSM2OBLK6QooA0LjYg5TYJLE7rca95u2/RKpMZ15WfW9Ri3qbFJRfiS0zbSQqvlf4w==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { - "glob": "^11.0.0", + "glob": "^13.0.0", "mkdirp": "^3.0.1", "path-scurry": "^2.0.0", "rimraf": "^6.0.0", - "tshy": "^3.0.0" + "tshy": "^3.1.0" }, "bin": { "sync-content": "dist/esm/bin.mjs" @@ -12698,22 +12498,16 @@ } }, "node_modules/sync-content/node_modules/glob": { - "version": "11.0.3", - "resolved": "https://registry.npmjs.org/glob/-/glob-11.0.3.tgz", - "integrity": "sha512-2Nim7dha1KVkaiF4q6Dj+ngPPMdfvLJEOpZk/jKiUAkqKebpGAWQXAq9z1xu9HKu5lWfqw/FASuccEjyznjPaA==", + "version": "13.0.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.0.tgz", + "integrity": "sha512-tvZgpqk6fz4BaNZ66ZsRaZnbHvP/jG3uKJvAZOwEVUL4RTA5nJeeLYfyN9/VA8NX/V3IBG+hkeuGpKjvELkVhA==", "dev": true, - "license": "ISC", + "license": "BlueOak-1.0.0", "dependencies": { - "foreground-child": "^3.3.1", - "jackspeak": "^4.1.1", - "minimatch": "^10.0.3", + "minimatch": "^10.1.1", "minipass": "^7.1.2", - "package-json-from-dist": "^1.0.0", "path-scurry": "^2.0.0" }, - "bin": { - "glob": "dist/esm/bin.mjs" - }, "engines": { "node": "20 || >=22" }, @@ -12721,12 +12515,22 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/sync-content/node_modules/lru-cache": { + "version": "11.2.4", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.4.tgz", + "integrity": "sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, "node_modules/sync-content/node_modules/minimatch": { - "version": "10.0.3", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.0.3.tgz", - "integrity": "sha512-IPZ167aShDZZUMdRk66cyQAW3qr0WzbHkPdMYa8bzZhlHhO3jALbKdxcaak7W9FfT2rZNpQuUu4Od7ILEpXSaw==", + "version": "10.1.1", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.1.1.tgz", + "integrity": "sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==", "dev": true, - "license": "ISC", + "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/brace-expansion": "^5.0.0" }, @@ -12737,18 +12541,15 @@ "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/sync-content/node_modules/rimraf": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-6.0.1.tgz", - "integrity": "sha512-9dkvaxAsk/xNXSJzMgFqqMCuFgt2+KsOFek3TMLfo8NCPfWpBmqwyNn5Y+NX56QUYfCtsyhF3ayiboEoUmJk/A==", + "node_modules/sync-content/node_modules/path-scurry": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.1.tgz", + "integrity": "sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==", "dev": true, - "license": "ISC", + "license": "BlueOak-1.0.0", "dependencies": { - "glob": "^11.0.0", - "package-json-from-dist": "^1.0.0" - }, - "bin": { - "rimraf": "dist/esm/bin.mjs" + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" }, "engines": { "node": "20 || >=22" @@ -12774,9 +12575,9 @@ } }, "node_modules/tapable": { - "version": "2.2.3", - "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.3.tgz", - "integrity": "sha512-ZL6DDuAlRlLGghwcfmSn9sK3Hr6ArtyudlSAiCqQ6IfE+b+HHbydbYDIG15IfS5do+7XQQBdBiubF/cV2dnDzg==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.0.tgz", + "integrity": "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==", "dev": true, "license": "MIT", "engines": { @@ -12787,6 +12588,21 @@ "url": "https://opencollective.com/webpack" } }, + "node_modules/test-exclude": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-7.0.1.tgz", + "integrity": "sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==", + "dev": true, + "license": "ISC", + "dependencies": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^10.4.1", + "minimatch": "^9.0.4" + }, + "engines": { + "node": ">=18" + } + }, "node_modules/tinybench": { "version": "2.9.0", "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", @@ -12796,57 +12612,26 @@ }, "node_modules/tinyexec": { "version": "0.3.2", - "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz", - "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==", - "dev": true, - "license": "MIT" - }, - "node_modules/tinyglobby": { - "version": "0.2.14", - "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.14.tgz", - "integrity": "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "fdir": "^6.4.4", - "picomatch": "^4.0.2" - }, - "engines": { - "node": ">=12.0.0" - }, - "funding": { - "url": "https://github.com/sponsors/SuperchupuDev" - } - }, - "node_modules/tinyglobby/node_modules/fdir": { - "version": "6.5.0", - "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", - "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12.0.0" - }, - "peerDependencies": { - "picomatch": "^3 || ^4" - }, - "peerDependenciesMeta": { - "picomatch": { - "optional": true - } - } + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz", + "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==", + "dev": true, + "license": "MIT" }, - "node_modules/tinyglobby/node_modules/picomatch": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", - "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", + "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", "dev": true, "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.3" + }, "engines": { - "node": ">=12" + "node": ">=12.0.0" }, "funding": { - "url": "https://github.com/sponsors/jonschlinkert" + "url": "https://github.com/sponsors/SuperchupuDev" } }, "node_modules/tinypool": { @@ -12870,9 +12655,9 @@ } }, "node_modules/tinyspy": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.3.tgz", - "integrity": "sha512-t2T/WLB2WRgZ9EpE4jgPJ9w+i66UZfDc8wHh0xrwiRNN+UwH98GIJkTeZqX9rg0i0ptwzqW+uYeIF0T4F8LR7A==", + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.4.tgz", + "integrity": "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==", "dev": true, "license": "MIT", "engines": { @@ -12880,26 +12665,20 @@ } }, "node_modules/title-case": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/title-case/-/title-case-3.0.3.tgz", - "integrity": "sha512-e1zGYRvbffpcHIrnuqT0Dh+gEJtDaxDSoG4JAIpq4oDFyooziLBIiYQv0GBT4FUAnUop5uZ1hiIAj7oAF6sOCA==", + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/title-case/-/title-case-4.3.2.tgz", + "integrity": "sha512-I/nkcBo73mO42Idfv08jhInV61IMb61OdIFxk+B4Gu1oBjWBPOLmhZdsli+oJCVaD+86pYQA93cJfFt224ZFAA==", "dev": true, - "license": "MIT", - "dependencies": { - "tslib": "^2.0.3" - } + "license": "MIT" }, "node_modules/tmp": { - "version": "0.0.33", - "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", - "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz", + "integrity": "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==", "dev": true, "license": "MIT", - "dependencies": { - "os-tmpdir": "~1.0.2" - }, "engines": { - "node": ">=0.6.0" + "node": ">=14.14" } }, "node_modules/to-regex-range": { @@ -12907,6 +12686,7 @@ "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", "dev": true, + "license": "MIT", "dependencies": { "is-number": "^7.0.0" }, @@ -12918,6 +12698,7 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", "engines": { "node": ">=0.6" } @@ -12929,10 +12710,11 @@ "license": "MIT" }, "node_modules/ts-api-utils": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.1.0.tgz", - "integrity": "sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ==", + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.4.0.tgz", + "integrity": "sha512-3TaVTaAv2gTiMB35i3FiGJaRfwb3Pyn/j3m/bfAvGe8FB7CF6u+LMYqYlDh7reQf7UNvoTvdfAqHGmPGOSsPmA==", "dev": true, + "license": "MIT", "engines": { "node": ">=18.12" }, @@ -12963,36 +12745,23 @@ "typescript": ">=4.0.0" } }, - "node_modules/ts-declaration-location/node_modules/picomatch": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", - "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/jonschlinkert" - } - }, "node_modules/tshy": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/tshy/-/tshy-3.0.2.tgz", - "integrity": "sha512-8GkWnAfmNXxl8iDTZ1o2H4jdaj9H7HeDKkr5qd0ZhQBCNA41D3xqTyg2Ycs51VCfmjJ5e+0v9AUmD6ylAI9Bgw==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/tshy/-/tshy-3.1.0.tgz", + "integrity": "sha512-DPBaaJSqcKFLSHTiqm3Xl2Phl7m1RtLNMe7J8qyoYO+tb2EW+txRp2NHR746GcrVicUUcNzfpm0yU1suQHRIwQ==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { - "chalk": "^5.3.0", - "chokidar": "^3.6.0", - "foreground-child": "^3.1.1", - "minimatch": "^10.0.0", + "chalk": "^5.6.2", + "chokidar": "^4.0.3", + "foreground-child": "^3.3.1", + "minimatch": "^10.0.3", "mkdirp": "^3.0.1", "polite-json": "^5.0.0", "resolve-import": "^2.0.0", - "rimraf": "^6.0.0", + "rimraf": "^6.0.1", "sync-content": "^2.0.1", - "typescript": "^5.5.3", + "typescript": "^5.9.3", "walk-up-path": "^4.0.0" }, "bin": { @@ -13002,49 +12771,12 @@ "node": "20 || >=22" } }, - "node_modules/tshy/node_modules/chalk": { - "version": "5.6.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.0.tgz", - "integrity": "sha512-46QrSQFyVSEyYAgQ22hQ+zDa60YHA4fBstHmtSApj1Y5vKtG27fWowW03jCk5KcbXEWPZUIR894aARCA/G1kfQ==", - "dev": true, - "license": "MIT", - "engines": { - "node": "^12.17.0 || ^14.13 || >=16.0.0" - }, - "funding": { - "url": "https://github.com/chalk/chalk?sponsor=1" - } - }, - "node_modules/tshy/node_modules/glob": { - "version": "11.0.3", - "resolved": "https://registry.npmjs.org/glob/-/glob-11.0.3.tgz", - "integrity": "sha512-2Nim7dha1KVkaiF4q6Dj+ngPPMdfvLJEOpZk/jKiUAkqKebpGAWQXAq9z1xu9HKu5lWfqw/FASuccEjyznjPaA==", - "dev": true, - "license": "ISC", - "dependencies": { - "foreground-child": "^3.3.1", - "jackspeak": "^4.1.1", - "minimatch": "^10.0.3", - "minipass": "^7.1.2", - "package-json-from-dist": "^1.0.0", - "path-scurry": "^2.0.0" - }, - "bin": { - "glob": "dist/esm/bin.mjs" - }, - "engines": { - "node": "20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, "node_modules/tshy/node_modules/minimatch": { - "version": "10.0.3", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.0.3.tgz", - "integrity": "sha512-IPZ167aShDZZUMdRk66cyQAW3qr0WzbHkPdMYa8bzZhlHhO3jALbKdxcaak7W9FfT2rZNpQuUu4Od7ILEpXSaw==", + "version": "10.1.1", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.1.1.tgz", + "integrity": "sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==", "dev": true, - "license": "ISC", + "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/brace-expansion": "^5.0.0" }, @@ -13055,26 +12787,6 @@ "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/tshy/node_modules/rimraf": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-6.0.1.tgz", - "integrity": "sha512-9dkvaxAsk/xNXSJzMgFqqMCuFgt2+KsOFek3TMLfo8NCPfWpBmqwyNn5Y+NX56QUYfCtsyhF3ayiboEoUmJk/A==", - "dev": true, - "license": "ISC", - "dependencies": { - "glob": "^11.0.0", - "package-json-from-dist": "^1.0.0" - }, - "bin": { - "rimraf": "dist/esm/bin.mjs" - }, - "engines": { - "node": "20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, "node_modules/tslib": { "version": "2.8.1", "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", @@ -13087,6 +12799,7 @@ "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", "dev": true, + "license": "MIT", "dependencies": { "prelude-ls": "^1.2.1" }, @@ -13099,6 +12812,7 @@ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", "dev": true, + "license": "(MIT OR CC0-1.0)", "engines": { "node": ">=10" }, @@ -13110,6 +12824,7 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz", "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==", + "license": "MIT", "dependencies": { "content-type": "^1.0.5", "media-typer": "^1.1.0", @@ -13120,10 +12835,11 @@ } }, "node_modules/typescript": { - "version": "5.8.3", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", - "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", "dev": true, + "license": "Apache-2.0", "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -13133,16 +12849,16 @@ } }, "node_modules/typescript-eslint": { - "version": "8.42.0", - "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.42.0.tgz", - "integrity": "sha512-ozR/rQn+aQXQxh1YgbCzQWDFrsi9mcg+1PM3l/z5o1+20P7suOIaNg515bpr/OYt6FObz/NHcBstydDLHWeEKg==", + "version": "8.52.0", + "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.52.0.tgz", + "integrity": "sha512-atlQQJ2YkO4pfTVQmQ+wvYQwexPDOIgo+RaVcD7gHgzy/IQA+XTyuxNM9M9TVXvttkF7koBHmcwisKdOAf2EcA==", "dev": true, "license": "MIT", "dependencies": { - "@typescript-eslint/eslint-plugin": "8.42.0", - "@typescript-eslint/parser": "8.42.0", - "@typescript-eslint/typescript-estree": "8.42.0", - "@typescript-eslint/utils": "8.42.0" + "@typescript-eslint/eslint-plugin": "8.52.0", + "@typescript-eslint/parser": "8.52.0", + "@typescript-eslint/typescript-estree": "8.52.0", + "@typescript-eslint/utils": "8.52.0" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -13175,6 +12891,7 @@ "resolved": "https://registry.npmjs.org/unc-path-regex/-/unc-path-regex-0.1.2.tgz", "integrity": "sha512-eXL4nmJT7oCpkZsHZUOJo8hcX3GbsiDOa0Qu9F646fi8dT3XuSVopVqAcEiVzSKKH7UoDti23wNX3qGFxcW5Qg==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -13182,7 +12899,8 @@ "node_modules/undici-types": { "version": "6.21.0", "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", - "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==" + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "license": "MIT" }, "node_modules/universalify": { "version": "2.0.1", @@ -13198,14 +12916,15 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "license": "MIT", "engines": { "node": ">= 0.8" } }, "node_modules/update-browserslist-db": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz", - "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==", + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", "dev": true, "funding": [ { @@ -13221,6 +12940,7 @@ "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" @@ -13232,31 +12952,12 @@ "browserslist": ">= 4.21.0" } }, - "node_modules/upper-case": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/upper-case/-/upper-case-2.0.2.tgz", - "integrity": "sha512-KgdgDGJt2TpuwBUIjgG6lzw2GWFRCW9Qkfkiv0DxqHHLYJHmtmdUIKcZd8rHgFSjopVTlw6ggzCm1b8MFQwikg==", - "dev": true, - "license": "MIT", - "dependencies": { - "tslib": "^2.0.3" - } - }, - "node_modules/upper-case-first": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/upper-case-first/-/upper-case-first-2.0.2.tgz", - "integrity": "sha512-514ppYHBaKwfJRK/pNC6c/OxfGa0obSnAl106u97Ed0I625Nin96KAjttZF6ZL3e1XLtphxnqrOi9iWgm+u+bg==", - "dev": true, - "license": "MIT", - "dependencies": { - "tslib": "^2.0.3" - } - }, "node_modules/uri-js": { "version": "4.4.1", "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "punycode": "^2.1.0" } @@ -13286,6 +12987,7 @@ "resolved": "https://registry.npmjs.org/v8flags/-/v8flags-4.0.1.tgz", "integrity": "sha512-fcRLaS4H/hrZk9hYwbdRM35D0U8IYMfEClhXxCivOojl+yTRAZH3Zy2sSy6qVCiGbV9YAtPssP6jaChqC9vPCg==", "dev": true, + "license": "MIT", "engines": { "node": ">= 10.13.0" } @@ -13294,23 +12996,24 @@ "version": "1.1.2", "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "license": "MIT", "engines": { "node": ">= 0.8" } }, "node_modules/vite": { - "version": "7.1.4", - "resolved": "https://registry.npmjs.org/vite/-/vite-7.1.4.tgz", - "integrity": "sha512-X5QFK4SGynAeeIt+A7ZWnApdUyHYm+pzv/8/A57LqSGcI88U6R6ipOs3uCesdc6yl7nl+zNO0t8LmqAdXcQihw==", + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz", + "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==", "dev": true, "license": "MIT", "dependencies": { - "esbuild": "^0.25.0", + "esbuild": "^0.27.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", - "tinyglobby": "^0.2.14" + "tinyglobby": "^0.2.15" }, "bin": { "vite": "bin/vite.js" @@ -13396,37 +13099,6 @@ "url": "https://opencollective.com/vitest" } }, - "node_modules/vite/node_modules/fdir": { - "version": "6.5.0", - "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", - "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12.0.0" - }, - "peerDependencies": { - "picomatch": "^3 || ^4" - }, - "peerDependenciesMeta": { - "picomatch": { - "optional": true - } - } - }, - "node_modules/vite/node_modules/picomatch": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", - "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/jonschlinkert" - } - }, "node_modules/vitest": { "version": "3.2.4", "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.4.tgz", @@ -13500,19 +13172,6 @@ } } }, - "node_modules/vitest/node_modules/picomatch": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", - "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/jonschlinkert" - } - }, "node_modules/vscode-languageserver-textdocument": { "version": "1.0.12", "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.12.tgz", @@ -13567,6 +13226,7 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "license": "ISC", "dependencies": { "isexe": "^2.0.0" }, @@ -13599,6 +13259,7 @@ "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } @@ -13611,10 +13272,11 @@ "license": "MIT" }, "node_modules/wrap-ansi": { - "version": "9.0.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.0.tgz", - "integrity": "sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==", + "version": "9.0.2", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz", + "integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==", "dev": true, + "license": "MIT", "dependencies": { "ansi-styles": "^6.2.1", "string-width": "^7.0.0", @@ -13646,12 +13308,31 @@ "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, - "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, - "license": "MIT" + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } }, "node_modules/wrap-ansi-cjs/node_modules/is-fullwidth-code-point": { "version": "3.0.0", @@ -13678,49 +13359,49 @@ "node": ">=8" } }, - "node_modules/wrap-ansi/node_modules/ansi-regex": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", - "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, - "engines": { - "node": ">=12" + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" }, - "funding": { - "url": "https://github.com/chalk/ansi-regex?sponsor=1" + "engines": { + "node": ">=8" } }, - "node_modules/wrap-ansi/node_modules/ansi-styles": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", - "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "node_modules/wrap-ansi/node_modules/emoji-regex": { + "version": "10.6.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz", + "integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==", "dev": true, - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/chalk/ansi-styles?sponsor=1" - } + "license": "MIT" }, - "node_modules/wrap-ansi/node_modules/strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "node_modules/wrap-ansi/node_modules/string-width": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz", + "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==", "dev": true, + "license": "MIT", "dependencies": { - "ansi-regex": "^6.0.1" + "emoji-regex": "^10.3.0", + "get-east-asian-width": "^1.0.0", + "strip-ansi": "^7.1.0" }, "engines": { - "node": ">=12" + "node": ">=18" }, "funding": { - "url": "https://github.com/chalk/strip-ansi?sponsor=1" + "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", - "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" }, "node_modules/xdg-basedir": { "version": "5.1.0", @@ -13757,12 +13438,13 @@ "version": "3.1.1", "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", - "dev": true + "dev": true, + "license": "ISC" }, "node_modules/yaml": { - "version": "2.8.1", - "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.1.tgz", - "integrity": "sha512-lcYcMxX2PO9XMGvAJkJ3OsNMw+/7FKes7/hgerGUYWIoWu5j/+YQqcZr5JnPZWzOsEBgMbSbiSTn/dv/69Mkpw==", + "version": "2.8.2", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.2.tgz", + "integrity": "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==", "dev": true, "license": "ISC", "bin": { @@ -13770,6 +13452,9 @@ }, "engines": { "node": ">= 14.6" + }, + "funding": { + "url": "https://github.com/sponsors/eemeli" } }, "node_modules/yargs": { @@ -13799,11 +13484,14 @@ "node": ">=12" } }, - "node_modules/yargs/node_modules/emoji-regex": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "license": "MIT" + "node_modules/yargs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } }, "node_modules/yargs/node_modules/is-fullwidth-code-point": { "version": "3.0.0", @@ -13828,11 +13516,24 @@ "node": ">=8" } }, + "node_modules/yargs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/yocto-queue": { "version": "0.1.0", "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=10" }, @@ -13841,9 +13542,9 @@ } }, "node_modules/yoctocolors-cjs": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/yoctocolors-cjs/-/yoctocolors-cjs-2.1.2.tgz", - "integrity": "sha512-cYVsTjKl8b+FrnidjibDWskAv7UKOfcwaVZdp/it9n1s9fU3IkgDbhdIRKCW4JDsAlECJY0ytoVPT3sK6kideA==", + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/yoctocolors-cjs/-/yoctocolors-cjs-2.1.3.tgz", + "integrity": "sha512-U/PBtDf35ff0D8X8D0jfdzHYEPFxAI7jJlxZXwCSez5M3190m+QobIfh+sWDWSHMCWWJN2AWamkegn6vr6YBTw==", "dev": true, "license": "MIT", "engines": { @@ -13854,20 +13555,21 @@ } }, "node_modules/zod": { - "version": "3.25.42", - "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.42.tgz", - "integrity": "sha512-PcALTLskaucbeHc41tU/xfjfhcz8z0GdhhDcSgrCTmSazUuqnYqiXO63M0QUBVwpBlsLsNVn5qHSC5Dw3KZvaQ==", + "version": "3.25.76", + "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz", + "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==", "license": "MIT", "funding": { "url": "https://github.com/sponsors/colinhacks" } }, "node_modules/zod-to-json-schema": { - "version": "3.24.5", - "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.5.tgz", - "integrity": "sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g==", + "version": "3.25.1", + "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.1.tgz", + "integrity": "sha512-pM/SU9d3YAggzi6MtR4h7ruuQlqKtad8e9S0fmxcMi+ueAK5Korys/aWcV9LIIHTVbj01NdzxcnXSN+O74ZIVA==", + "license": "ISC", "peerDependencies": { - "zod": "^3.24.1" + "zod": "^3.25 || ^4" } } } diff --git a/package.json b/package.json index ea2801c..89b28f4 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@mapbox/mcp-server", - "version": "0.8.0", + "version": "0.8.1", "description": "Mapbox MCP server.", "mcpName": "io.github.mapbox/mcp-server", "main": "./dist/commonjs/index.js", @@ -76,7 +76,7 @@ ], "dependencies": { "@mcp-ui/server": "^5.13.1", - "@modelcontextprotocol/sdk": "^1.21.1", + "@modelcontextprotocol/sdk": "^1.25.1", "@opentelemetry/api": "^1.9.0", "@opentelemetry/auto-instrumentations-node": "^0.56.0", "@opentelemetry/exporter-trace-otlp-http": "^0.56.0", diff --git a/patches/@modelcontextprotocol+sdk+1.21.1.patch b/patches/@modelcontextprotocol+sdk+1.21.1.patch deleted file mode 100644 index a9495ec..0000000 --- a/patches/@modelcontextprotocol+sdk+1.21.1.patch +++ /dev/null @@ -1,54 +0,0 @@ -diff --git a/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/mcp.js b/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/mcp.js -index 31819ff..ae95a35 100644 ---- a/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/mcp.js -+++ b/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/mcp.js -@@ -100,12 +100,16 @@ class McpServer { - } - if (tool.outputSchema && !result.isError) { - if (!result.structuredContent) { -- throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Output validation error: Tool ${request.params.name} has an output schema but no structured content was provided`); -- } -- // if the tool has an output schema, validate structured content -- const parseResult = await tool.outputSchema.safeParseAsync(result.structuredContent); -- if (!parseResult.success) { -- throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${request.params.name}: ${parseResult.error.message}`); -+ // Log warning but don't throw - allow tools to omit structured content -+ console.warn(`[MCP SDK Patch] Output validation warning: Tool ${request.params.name} has an output schema but no structured content was provided`); -+ } else { -+ // if the tool has an output schema, validate structured content -+ const parseResult = await tool.outputSchema.safeParseAsync(result.structuredContent); -+ if (!parseResult.success) { -+ // Log warning but don't throw - allow schema mismatches -+ console.warn(`[MCP SDK Patch] Output validation warning: Invalid structured content for tool ${request.params.name}: ${parseResult.error.message}`); -+ // Keep the structuredContent despite validation failure -+ } - } - } - } -diff --git a/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js b/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js -index d5aadc5..b527424 100644 ---- a/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js -+++ b/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js -@@ -97,12 +97,16 @@ export class McpServer { - } - if (tool.outputSchema && !result.isError) { - if (!result.structuredContent) { -- throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${request.params.name} has an output schema but no structured content was provided`); -- } -- // if the tool has an output schema, validate structured content -- const parseResult = await tool.outputSchema.safeParseAsync(result.structuredContent); -- if (!parseResult.success) { -- throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${request.params.name}: ${parseResult.error.message}`); -+ // Log warning but don't throw - allow tools to omit structured content -+ console.warn(`[MCP SDK Patch] Output validation warning: Tool ${request.params.name} has an output schema but no structured content was provided`); -+ } else { -+ // if the tool has an output schema, validate structured content -+ const parseResult = await tool.outputSchema.safeParseAsync(result.structuredContent); -+ if (!parseResult.success) { -+ // Log warning but don't throw - allow schema mismatches -+ console.warn(`[MCP SDK Patch] Output validation warning: Invalid structured content for tool ${request.params.name}: ${parseResult.error.message}`); -+ // Keep the structuredContent despite validation failure -+ } - } - } - } diff --git a/patches/@modelcontextprotocol+sdk+1.25.1.patch b/patches/@modelcontextprotocol+sdk+1.25.1.patch new file mode 100644 index 0000000..7eb8747 --- /dev/null +++ b/patches/@modelcontextprotocol+sdk+1.25.1.patch @@ -0,0 +1,122 @@ +diff --git a/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/mcp.js b/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/mcp.js +index e10bb3d..2e99bee 100644 +--- a/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/mcp.js ++++ b/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/mcp.js +@@ -197,15 +197,20 @@ class McpServer { + return; + } + if (!result.structuredContent) { +- throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`); ++ // Log warning but don't throw - allow tools to omit structured content ++ console.warn(`[MCP SDK Patch] Output validation warning: Tool ${toolName} has an output schema but no structured content was provided`); + } +- // if the tool has an output schema, validate structured content +- const outputObj = (0, zod_compat_js_1.normalizeObjectSchema)(tool.outputSchema); +- const parseResult = await (0, zod_compat_js_1.safeParseAsync)(outputObj, result.structuredContent); +- if (!parseResult.success) { +- const error = 'error' in parseResult ? parseResult.error : 'Unknown error'; +- const errorMessage = (0, zod_compat_js_1.getParseErrorMessage)(error); +- throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`); ++ else { ++ // if the tool has an output schema, validate structured content ++ const outputObj = (0, zod_compat_js_1.normalizeObjectSchema)(tool.outputSchema); ++ const parseResult = await (0, zod_compat_js_1.safeParseAsync)(outputObj, result.structuredContent); ++ if (!parseResult.success) { ++ const error = 'error' in parseResult ? parseResult.error : 'Unknown error'; ++ const errorMessage = (0, zod_compat_js_1.getParseErrorMessage)(error); ++ // Log warning but don't throw - allow schema mismatches ++ console.warn(`[MCP SDK Patch] Output validation warning: Invalid structured content for tool ${toolName}: ${errorMessage}`); ++ // Keep the structuredContent despite validation failure ++ } + } + } + /** +diff --git a/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js b/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js +index 23639ce..75f18b5 100644 +--- a/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js ++++ b/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js +@@ -85,6 +85,9 @@ export class McpServer { + execution: tool.execution, + _meta: tool._meta + }; ++ if (tool.icons) { ++ toolDefinition.icons = tool.icons; ++ } + if (tool.outputSchema) { + const obj = normalizeObjectSchema(tool.outputSchema); + if (obj) { +@@ -194,15 +197,20 @@ export class McpServer { + return; + } + if (!result.structuredContent) { +- throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`); ++ // Log warning but don't throw - allow tools to omit structured content ++ console.warn(`[MCP SDK Patch] Output validation warning: Tool ${toolName} has an output schema but no structured content was provided`); + } +- // if the tool has an output schema, validate structured content +- const outputObj = normalizeObjectSchema(tool.outputSchema); +- const parseResult = await safeParseAsync(outputObj, result.structuredContent); +- if (!parseResult.success) { +- const error = 'error' in parseResult ? parseResult.error : 'Unknown error'; +- const errorMessage = getParseErrorMessage(error); +- throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`); ++ else { ++ // if the tool has an output schema, validate structured content ++ const outputObj = normalizeObjectSchema(tool.outputSchema); ++ const parseResult = await safeParseAsync(outputObj, result.structuredContent); ++ if (!parseResult.success) { ++ const error = 'error' in parseResult ? parseResult.error : 'Unknown error'; ++ const errorMessage = getParseErrorMessage(error); ++ // Log warning but don't throw - allow schema mismatches ++ console.warn(`[MCP SDK Patch] Output validation warning: Invalid structured content for tool ${toolName}: ${errorMessage}`); ++ // Keep the structuredContent despite validation failure ++ } + } + } + /** +@@ -602,7 +610,7 @@ export class McpServer { + } + return registeredPrompt; + } +- _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) { ++ _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, icons, handler) { + // Validate tool name according to SEP specification + validateAndWarnToolName(name); + const registeredTool = { +@@ -613,6 +621,7 @@ export class McpServer { + annotations, + execution, + _meta, ++ icons, + handler: handler, + enabled: true, + disable: () => registeredTool.update({ enabled: false }), +@@ -641,6 +650,8 @@ export class McpServer { + registeredTool.annotations = updates.annotations; + if (typeof updates._meta !== 'undefined') + registeredTool._meta = updates._meta; ++ if (typeof updates.icons !== 'undefined') ++ registeredTool.icons = updates.icons; + if (typeof updates.enabled !== 'undefined') + registeredTool.enabled = updates.enabled; + this.sendToolListChanged(); +@@ -690,7 +701,7 @@ export class McpServer { + } + } + const callback = rest[0]; +- return this._createRegisteredTool(name, undefined, description, inputSchema, outputSchema, annotations, { taskSupport: 'forbidden' }, undefined, callback); ++ return this._createRegisteredTool(name, undefined, description, inputSchema, outputSchema, annotations, { taskSupport: 'forbidden' }, undefined, undefined, callback); + } + /** + * Registers a tool with a config object and callback. +@@ -699,8 +710,8 @@ export class McpServer { + if (this._registeredTools[name]) { + throw new Error(`Tool ${name} is already registered`); + } +- const { title, description, inputSchema, outputSchema, annotations, _meta } = config; +- return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: 'forbidden' }, _meta, cb); ++ const { title, description, inputSchema, outputSchema, annotations, _meta, icons } = config; ++ return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: 'forbidden' }, _meta, icons, cb); + } + prompt(name, ...rest) { + if (this._registeredPrompts[name]) { From 6df8bf995e8966f1a64e7dd4098ac3e672aa58b2 Mon Sep 17 00:00:00 2001 From: Matthew Podwysocki Date: Wed, 7 Jan 2026 11:28:19 -0500 Subject: [PATCH 4/8] Add distance_tool for offline geospatial calculations MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implements the first offline geospatial tool using Turf.js for calculating great-circle distance between two geographic coordinates. Features: - Calculate distance between any two points on Earth - Support for multiple units: km, miles, meters, feet, nautical miles - Haversine formula for accurate great-circle distance - Completely offline - no API calls required - Fast local calculations with OpenTelemetry tracing Technical details: - Uses Turf.js distance function - Follows project patterns (BaseTool, proper annotations) - Coordinate format: { longitude, latitude } objects (not tuples) - Read-only, idempotent, closed-world tool - Full test coverage with 8 test cases Dependencies added: - @turf/turf: Comprehensive geospatial analysis library All 433 tests passing ✅ 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 --- package-lock.json | 2462 ++++++++++++++++- package.json | 1 + server.json | 4 +- .../DistanceTool.input.schema.ts | 34 + .../DistanceTool.output.schema.ts | 29 + src/tools/distance-tool/DistanceTool.ts | 120 + src/tools/toolRegistry.ts | 2 + src/utils/versionUtils-cjs.cjs | 48 + src/utils/versionUtils-cjs.cjs.map | 1 + src/utils/versionUtils-cjs.d.cts | 9 + src/utils/versionUtils-cjs.d.cts.map | 1 + test/tools/annotations.test.ts | 15 +- test/tools/distance-tool/DistanceTool.test.ts | 101 + tsconfig.src.tsbuildinfo | 1 + 14 files changed, 2708 insertions(+), 120 deletions(-) create mode 100644 src/tools/distance-tool/DistanceTool.input.schema.ts create mode 100644 src/tools/distance-tool/DistanceTool.output.schema.ts create mode 100644 src/tools/distance-tool/DistanceTool.ts create mode 100644 src/utils/versionUtils-cjs.cjs create mode 100644 src/utils/versionUtils-cjs.cjs.map create mode 100644 src/utils/versionUtils-cjs.d.cts create mode 100644 src/utils/versionUtils-cjs.d.cts.map create mode 100644 test/tools/distance-tool/DistanceTool.test.ts create mode 100644 tsconfig.src.tsbuildinfo diff --git a/package-lock.json b/package-lock.json index bece05b..b4cb92a 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "@mapbox/mcp-server", - "version": "0.8.0", + "version": "0.8.1", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "@mapbox/mcp-server", - "version": "0.8.0", + "version": "0.8.1", "hasInstallScript": true, "license": "MIT", "dependencies": { @@ -20,6 +20,7 @@ "@opentelemetry/sdk-node": "^0.56.0", "@opentelemetry/sdk-trace-base": "^1.30.1", "@opentelemetry/semantic-conventions": "^1.30.1", + "@turf/turf": "^7.3.1", "zod": "^3.25.42" }, "bin": { @@ -6196,134 +6197,2160 @@ ], "dev": true, "license": "MIT", - "optional": true, - "os": [ - "linux" - ] + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.55.1.tgz", + "integrity": "sha512-/0PenBCmqM4ZUd0190j7J0UsQ/1nsi735iPRakO8iPciE7BQ495Y6msPzaOmvx0/pn+eJVVlZrNrSh4WSYLxNg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.55.1.tgz", + "integrity": "sha512-a8G4wiQxQG2BAvo+gU6XrReRRqj+pLS2NGXKm8io19goR+K8lw269eTrPkSdDTALwMmJp4th2Uh0D8J9bEV1vg==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.55.1.tgz", + "integrity": "sha512-bD+zjpFrMpP/hqkfEcnjXWHMw5BIghGisOKPj+2NaNDuVT+8Ds4mPf3XcPHuat1tz89WRL+1wbcxKY3WSbiT7w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.55.1.tgz", + "integrity": "sha512-eLXw0dOiqE4QmvikfQ6yjgkg/xDM+MdU9YJuP4ySTibXU0oAvnEWXt7UDJmD4UkYialMfOGFPJnIHSe/kdzPxg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.55.1.tgz", + "integrity": "sha512-xzm44KgEP11te3S2HCSyYf5zIzWmx3n8HDCc7EE59+lTcswEWNpvMLfd9uJvVX8LCg9QWG67Xt75AuHn4vgsXw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.55.1.tgz", + "integrity": "sha512-yR6Bl3tMC/gBok5cz/Qi0xYnVbIxGx5Fcf/ca0eB6/6JwOY+SRUcJfI0OpeTpPls7f194as62thCt/2BjxYN8g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.55.1.tgz", + "integrity": "sha512-3fZBidchE0eY0oFZBnekYCfg+5wAB0mbpCBuofh5mZuzIU/4jIVkbESmd2dOsFNS78b53CYv3OAtwqkZZmU5nA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.55.1.tgz", + "integrity": "sha512-xGGY5pXj69IxKb4yv/POoocPy/qmEGhimy/FoTpTSVju3FYXUQQMFCaZZXJVidsmGxRioZAwpThl/4zX41gRKg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.55.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.55.1.tgz", + "integrity": "sha512-SPEpaL6DX4rmcXtnhdrQYgzQ5W2uW3SCJch88lB2zImhJRhIIK44fkUrgIV/Q8yUNfw5oyZ5vkeQsZLhCb06lw==", + "cpu": [ + "x64" + ], + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@turf/along": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/along/-/along-7.3.1.tgz", + "integrity": "sha512-z84b9PKsUB69BhkeHA6oPqRO7VaJHwTid1SpuIbwWzDqHTpq8buJBKlrKgHIIthuVr5P/AZiEXmf3R4ifRhDmw==", + "license": "MIT", + "dependencies": { + "@turf/bearing": "7.3.1", + "@turf/destination": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/angle": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/angle/-/angle-7.3.1.tgz", + "integrity": "sha512-Pcb0Fg8WHsOMKFvIPaYfORrlLYdytWjVAkVTnAqJdmGI+2n+eLROPjJO2sJbpX9yU/dlBgujOB7a1d0PJjhHyQ==", + "license": "MIT", + "dependencies": { + "@turf/bearing": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/rhumb-bearing": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/area": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/area/-/area-7.3.1.tgz", + "integrity": "sha512-9nSiwt4zB5QDMcSoTxF28WpK1f741MNKcpUJDiHVRX08CZ4qfGWGV9ZIPQ8TVEn5RE4LyYkFuQ47Z9pdEUZE9Q==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/bbox": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/bbox/-/bbox-7.3.1.tgz", + "integrity": "sha512-/IyMKoS7P9B0ch5PIlQ6gMfoE8gRr48+cSbzlyexvEjuDuaAV1VURjH1jAthS0ipFG8RrFxFJKnp7TLL1Skong==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/bbox-clip": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/bbox-clip/-/bbox-clip-7.3.1.tgz", + "integrity": "sha512-YUeITFtp5QLbpSS0XyQa0GlgMqK4PMgjOeOGOTlWsfDYaqc5SErf7o5UyCOsLAPQW16QZVxJ26uTAE20YkluAA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/bbox-polygon": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/bbox-polygon/-/bbox-polygon-7.3.1.tgz", + "integrity": "sha512-2NvwPfuRtwJk7w5HIC/Knei3mUXrVT+t/0FB1zStgDbakmXrqKISaftlIh4YTOVlUsVnvq0tggjFMLZ/Xxo+lQ==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/bearing": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/bearing/-/bearing-7.3.1.tgz", + "integrity": "sha512-ex78l/LiY6uO6jO8AJepyWE6/tiWEbXjKLOgqUfJSkW23UcMVlhbAKzXDjbsdz9T66sXFC/6QNAh8oaZzmoo6w==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/bezier-spline": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/bezier-spline/-/bezier-spline-7.3.1.tgz", + "integrity": "sha512-7Mal/d8ttTQ5eu/mwgC53iH9eYBRTBHXsIqEEiTVHChh1iajNuS4/bwYdaxsQsRXKVaFfx+4dCy0cRmqhjgTrw==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-clockwise": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-clockwise/-/boolean-clockwise-7.3.1.tgz", + "integrity": "sha512-ik9j0CCrsp/JZ42tbCnyZg86YFoavEU/nyal3HsEgdY5WFYq43aMYqLPRi6yNqE48THEk3fl1BcfgJqAiUhDFA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-concave": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-concave/-/boolean-concave-7.3.1.tgz", + "integrity": "sha512-jAAt5MhqXSKmRmX7l09oeo9dObf7bMDuzfeUSSNAK+yAi9TE5QWlP4JtzOWC5+gKXsL8dvzE8mvsQj38FzQdEA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-contains": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-contains/-/boolean-contains-7.3.1.tgz", + "integrity": "sha512-VvytV9ZcUgnitzm5ILVWIoOhoZOh8VZ4dnweUJM3N+A77CzXXFk8e4NqPNZ6tZVPY3ehxzDXrq1+iN87pMcB7g==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/boolean-point-on-line": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-crosses": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-crosses/-/boolean-crosses-7.3.1.tgz", + "integrity": "sha512-Fn99AxTXQORiQjclUqUYQcA40oJJoJxMBFx/Vycd7v949Lnplt1qrUkBpbZNXQlvHF2gxrgirSfgBDaUnUJjzQ==", + "license": "MIT", + "dependencies": { + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/line-intersect": "7.3.1", + "@turf/polygon-to-line": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-disjoint": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-disjoint/-/boolean-disjoint-7.3.1.tgz", + "integrity": "sha512-bqVo+eAYaCq0lcr09zsZdWIAdv22UzGc/h2CCfaBwP5r4o/rFudNFLU9gb9BcM6dBUzrtTgBguShAZr7k3cGbw==", + "license": "MIT", + "dependencies": { + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/line-intersect": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/polygon-to-line": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-equal": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-equal/-/boolean-equal-7.3.1.tgz", + "integrity": "sha512-nEsmmNdwD1nzYZLsO6hPC/X/Uag+eT0yuWamD0XxJAQhXBsnSATxKisCJXVJgXvO8M0qvEMW1zZrUGB6Fjfzzw==", + "license": "MIT", + "dependencies": { + "@turf/clean-coords": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "geojson-equality-ts": "^1.0.2", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-intersects": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-intersects/-/boolean-intersects-7.3.1.tgz", + "integrity": "sha512-nc6W8qFdzFkfsR6p506HINGu85nHk/Skm+cw3TRQZ5/A44hjf0kYnbhvS3qrCAws3bR+/FKK8O1bsO/Udk8kkg==", + "license": "MIT", + "dependencies": { + "@turf/boolean-disjoint": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-overlap": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-overlap/-/boolean-overlap-7.3.1.tgz", + "integrity": "sha512-QhhsgCLzkwXIeZhaCmgE3H8yTANJGZatJ5IzQG3xnPTx7LiNAaa/ReN2/NroEv++8Yc0sr5Bkh6xWZOtew1dvQ==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/line-intersect": "7.3.1", + "@turf/line-overlap": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "geojson-equality-ts": "^1.0.2", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-parallel": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-parallel/-/boolean-parallel-7.3.1.tgz", + "integrity": "sha512-SXPyYiuaRB1ES/LtcUP11HWyloMJGzN1nYaCLG7H+6l2OKjVJl025qR6uxVElWCzAdElek9nGNeNya1hd9ZHaw==", + "license": "MIT", + "dependencies": { + "@turf/clean-coords": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/line-segment": "7.3.1", + "@turf/rhumb-bearing": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-point-in-polygon": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-point-in-polygon/-/boolean-point-in-polygon-7.3.1.tgz", + "integrity": "sha512-BUPW63vE43LctwkgannjmEFTX1KFR/18SS7WzFahJWK1ZoP0s1jrfxGX+pi0BH/3Dd9mA71hkGKDDnj1Ndcz0g==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "point-in-polygon-hao": "^1.1.0", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-point-on-line": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-point-on-line/-/boolean-point-on-line-7.3.1.tgz", + "integrity": "sha512-8Hywuv7XFpSc8nfH0BJBtt+XTcJ7OjfjpX2Sz+ty8gyiY/2nCLLqq6amu3ebr67ruqZTDpPNQoGGUbUePjF3rA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-touches": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-touches/-/boolean-touches-7.3.1.tgz", + "integrity": "sha512-XqrQzYGTakoTWeTWT274pfObpbIpAM7L8CzGUa04rJD0l3bv3VK4TUw0v6+bywi5ea6TnJzvOzgvzTb1DtvBKA==", + "license": "MIT", + "dependencies": { + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/boolean-point-on-line": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-valid": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-valid/-/boolean-valid-7.3.1.tgz", + "integrity": "sha512-lpw4J5HaV4Tv033s2j/i6QHt6Zx/8Lc90DTfOU0axgRSrs127kbKNJsmDEGvtmV7YjNp8aPbIG1wwAX9wg/dMA==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/boolean-crosses": "7.3.1", + "@turf/boolean-disjoint": "7.3.1", + "@turf/boolean-overlap": "7.3.1", + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/boolean-point-on-line": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/line-intersect": "7.3.1", + "@types/geojson": "^7946.0.10", + "geojson-polygon-self-intersections": "^1.2.1", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/boolean-within": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/boolean-within/-/boolean-within-7.3.1.tgz", + "integrity": "sha512-oxP4VU81RRCf59TXCBhVWEyJ5Lsr+wrqvqSAFxyBuur5oLmBqZdYyvL7FQJmYvG0uOxX7ohyHmSJMaTe4EhGDA==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/boolean-point-on-line": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/buffer": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/buffer/-/buffer-7.3.1.tgz", + "integrity": "sha512-jtdI0Ir3GwPyY1V2dFX039HNhD8MIYLX39c7b9AZdLh7kBuD2VgXJmPvhtnivqMV2SmRlS4fd9cKzNj369/cGg==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/center": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/jsts": "^2.7.1", + "@turf/meta": "7.3.1", + "@turf/projection": "7.3.1", + "@types/geojson": "^7946.0.10", + "d3-geo": "1.7.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/center": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/center/-/center-7.3.1.tgz", + "integrity": "sha512-czqNKLGGdik3phYsWCK5SHKBRkDulUArMlG4v62IQcNcRFq9MbOGqyN21GSshSMO792ynDeWzdXdcKmycQ14Yg==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/center-mean": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/center-mean/-/center-mean-7.3.1.tgz", + "integrity": "sha512-koVenhCl8JPEvtDwH6nhZpLAm9+7XOXosqKdkXyK1uDae3NRyoQQeIYD7nIJHJPCOyeacw6buWzAEoAleBj0XA==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/center-median": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/center-median/-/center-median-7.3.1.tgz", + "integrity": "sha512-XIvxqnSdcUFOev4WO8AEQth4U3uzfQkxYVkKhZrxpVitqEeSDm5v3ANUeVGYqQ/QNTWvFAFn4zB5+XRRd8tayA==", + "license": "MIT", + "dependencies": { + "@turf/center-mean": "7.3.1", + "@turf/centroid": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/center-of-mass": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/center-of-mass/-/center-of-mass-7.3.1.tgz", + "integrity": "sha512-w2O7RLc0tSs+eEsZCaWa1lYiACsaQTJtie/a4bj5ta1TDTAEjyxC6Rp6br4mN1XPzeSFbEuNw+q9/VdSXU/mGA==", + "license": "MIT", + "dependencies": { + "@turf/centroid": "7.3.1", + "@turf/convex": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/centroid": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/centroid/-/centroid-7.3.1.tgz", + "integrity": "sha512-hRnsDdVBH4pX9mAjYympb2q5W8TCMUMNEjcRrAF7HTCyjIuRmjJf8vUtlzf7TTn9RXbsvPc1vtm3kLw20Jm8DQ==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/circle": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/circle/-/circle-7.3.1.tgz", + "integrity": "sha512-UY2OM1OK7IuyrtN3YE8026ZM3xM9VIkqZ0vRZln8g33D0AogrJVJ/I9T81/VpRPlxTnrbDpzQxJQBH+3vPG/Ow==", + "license": "MIT", + "dependencies": { + "@turf/destination": "7.3.1", + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/clean-coords": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/clean-coords/-/clean-coords-7.3.1.tgz", + "integrity": "sha512-uNo4lnTekvkw8dUCXIVCc38nZiHBrpy5jn0T8hlodZo/A4XAChFtLQi8NLcX8rtXcaNxeJo+yaPfpP3PSVI2jw==", + "license": "MIT", + "dependencies": { + "@turf/boolean-point-on-line": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/clone": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/clone/-/clone-7.3.1.tgz", + "integrity": "sha512-r7xDOfw9ohA7PhZW+8X9RMsO4szB4YqkhEROaELJyLtQ1bo8VNFtndpZdE6YHQpD7Pjlvlb6i99q8w1QLisEPg==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/clusters": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/clusters/-/clusters-7.3.1.tgz", + "integrity": "sha512-ZELehyYnsozw+AHOc426abmPaGJOt46BHnCN+hwtPOkqEbvdZYu+16Y+cjiFnY7FwbvzBjDMb9HRtKJFlAmupg==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/clusters-dbscan": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/clusters-dbscan/-/clusters-dbscan-7.3.1.tgz", + "integrity": "sha512-rY1wbQlljRhX5e+XM/yw4dKs2HniN45v+Xf5Xde6nv23WyEf/LLjpyD5yrsLa1awfJjD/NmD6axGVebnBBn9YA==", + "license": "MIT", + "dependencies": { + "@turf/clone": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "rbush": "^3.0.1", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/clusters-kmeans": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/clusters-kmeans/-/clusters-kmeans-7.3.1.tgz", + "integrity": "sha512-HYvRninBY/b5ftkIkoVWjV/wHilNE56cdr6gTlrxuvm4EClilsLDSVYjeiMYU0pjI3xDTc7PlicQDGdnIavUqQ==", + "license": "MIT", + "dependencies": { + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "skmeans": "0.9.7", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/collect": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/collect/-/collect-7.3.1.tgz", + "integrity": "sha512-yVDz5YLcRGFipttb60Y4IAd7zWfbQk6mNW5Kt6/wa8+YueHFzsKJdtbErWfozCVuiKplQZWT5r+9J9g6RnhpjQ==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "rbush": "^3.0.1", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/combine": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/combine/-/combine-7.3.1.tgz", + "integrity": "sha512-iZBe36sKRq08fY3Ars0JpfYJm8N3LtLLnNzdTxHp8Ry2ORJGHvZHpcv3lQXWL7gyJwDPAye7pyrX7S99IB/1VA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/concave": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/concave/-/concave-7.3.1.tgz", + "integrity": "sha512-vZWqyAYH4qzOuiqPb+bj2jvpIGzYAH8byUhfFJ2gRFRL3/RfV8jdXL2r0Y6VFScqE6OLVGvtM3ITzXX1/9wTaA==", + "license": "MIT", + "dependencies": { + "@turf/clone": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/tin": "7.3.1", + "@types/geojson": "^7946.0.10", + "topojson-client": "3.x", + "topojson-server": "3.x", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/convex": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/convex/-/convex-7.3.1.tgz", + "integrity": "sha512-k2T8QVSie4w+KhwUxjzi/6S6VFr33H9gnUawOh4chCGAgje9PljUZLCGbktHgDfAjX1FVzyUyriH+dm86Z7njQ==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "concaveman": "^1.2.1", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/destination": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/destination/-/destination-7.3.1.tgz", + "integrity": "sha512-yyiJtbQJ4AB9Ny/FKDDNuWI9Sg4Jtd2PMpQPqOV3AFq8NNkg0xJSNmDHDxupb3oPqPWYPxyfVI3tBoF+Xhhoig==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/difference": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/difference/-/difference-7.3.1.tgz", + "integrity": "sha512-Ne2AR+1AdeH8aqY2VHcws+Z/1MHl8SlSbSWHBNVZUVEfvyzTrRg8/E+OC5vFaSUvNZXkB/OUufTCM9xsatLKXQ==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "polyclip-ts": "^0.16.8", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/dissolve": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/dissolve/-/dissolve-7.3.1.tgz", + "integrity": "sha512-Xmjl4E1aGRMdJjq+HfsiAXZtfMKruq7O+8xvsqnHM6E8iBWlJNSw8ucrNB5RZME8BUojx0q8bvXgS3k68koGyw==", + "license": "MIT", + "dependencies": { + "@turf/flatten": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "polyclip-ts": "^0.16.8", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/distance": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/distance/-/distance-7.3.1.tgz", + "integrity": "sha512-DK//doTGgYYjBkcWUywAe7wbZYcdP97hdEJ6rXYVYRoULwGGR3lhY96GNjozg6gaW9q2eSNYnZLpcL5iFVHqgw==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/distance-weight": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/distance-weight/-/distance-weight-7.3.1.tgz", + "integrity": "sha512-h82qLPeMxOfgN62ZysscQCu9IYB5AO+duw7peAQnMtFobpbcQK58158P0cNzxAoTVJXSO/mfR9dI9Zdz7NF75w==", + "license": "MIT", + "dependencies": { + "@turf/centroid": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/ellipse": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/ellipse/-/ellipse-7.3.1.tgz", + "integrity": "sha512-tcGbS+U7EktZg+UJad17LRU+8C067XDWdmURPCmycaib2zRxeNrImh2Y/589us6wsldlYYoBYRxDY/c1oxIUCA==", + "license": "MIT", + "dependencies": { + "@turf/destination": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/transform-rotate": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/envelope": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/envelope/-/envelope-7.3.1.tgz", + "integrity": "sha512-Sp3ct/LpWyHN5tTfPOcKXFoVDI1QH9BXtQ+aQzABFp3U5nY2Sz8LFg8SeFQm3K7PpoCnUwSfwDFA4aa+z+4l1g==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/bbox-polygon": "7.3.1", + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/explode": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/explode/-/explode-7.3.1.tgz", + "integrity": "sha512-H0Q8NnmrPoWKhsYYmVmkuT5F4t50N53ByGBf6Ys1n5B9YrFyrT+/aLDXF2C05r+QnW8nFtkM4lFG3ZSBHiq4Xg==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/flatten": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/flatten/-/flatten-7.3.1.tgz", + "integrity": "sha512-cM/uuQP8oZ4IDJG342uOlqQ8yD9RsAY9Gg9nsDOgJn6tN065aigRCNy2lfrNyLdK/CPTVEWQzx1EQa+zXGSgAg==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/flip": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/flip/-/flip-7.3.1.tgz", + "integrity": "sha512-6sF41pWY8Tw7w72hYc87sR9zzDei7UZ4Db/z0mKuNKueyzl4iTQ/H2JVd/XLZ7Tasz7H8htmrbUO0GR8GY7qiQ==", + "license": "MIT", + "dependencies": { + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/geojson-rbush": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/geojson-rbush/-/geojson-rbush-7.3.1.tgz", + "integrity": "sha512-EsrBBftZS5TvzRP2opLzwfnPXfmJi45KkGUcKSSFD0bxQe3BQUSmBrZbHMT8avB2s/XHrS/MniqsyeVOMwc35Q==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "rbush": "^3.0.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/great-circle": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/great-circle/-/great-circle-7.3.1.tgz", + "integrity": "sha512-pfs7PzBRgYEEyecM0ni6iEF19grn9FmbHyaLz7voYInmc2ZHfWQaxuY4dcf9cziWDaiPlbuyr/RyE6envg1xpw==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/helpers": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/helpers/-/helpers-7.3.1.tgz", + "integrity": "sha512-zkL34JVhi5XhsuMEO0MUTIIFEJ8yiW1InMu4hu/oRqamlY4mMoZql0viEmH6Dafh/p+zOl8OYvMJ3Vm3rFshgg==", + "license": "MIT", + "dependencies": { + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/hex-grid": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/hex-grid/-/hex-grid-7.3.1.tgz", + "integrity": "sha512-cWAKxlU1aa06976C3RhpcilDzLnWwXkH/atNIWKGpLV/HubHrMXxhp9VMBKWaqsLbdn5x2uJjv4MxwWw9/373g==", + "license": "MIT", + "dependencies": { + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/intersect": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/interpolate": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/interpolate/-/interpolate-7.3.1.tgz", + "integrity": "sha512-dquwDplzkSANMQdvxAu0dRF69EBIIlW/1zTPOB/BQfb/s7j6t8RskgbuV8ew1KpJPMmj7EbexejiMBtRWXTu4Q==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/centroid": "7.3.1", + "@turf/clone": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/hex-grid": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/point-grid": "7.3.1", + "@turf/square-grid": "7.3.1", + "@turf/triangle-grid": "7.3.1", + "@types/geojson": "^7946.0.10" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/intersect": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/intersect/-/intersect-7.3.1.tgz", + "integrity": "sha512-676688YnF9wpprMioQWvxPlUMhtTvYITzw4XoG3lQmLjd/yt2cByanQHWpzWauLfYUlfuL13AeRGdqXRhSkhTQ==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "polyclip-ts": "^0.16.8", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/invariant": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/invariant/-/invariant-7.3.1.tgz", + "integrity": "sha512-IdZJfDjIDCLH+Gu2yLFoSM7H23sdetIo5t4ET1/25X8gi3GE2XSqbZwaGjuZgNh02nisBewLqNiJs2bo+hrqZA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/isobands": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/isobands/-/isobands-7.3.1.tgz", + "integrity": "sha512-An6+yUSrOStQSpZwKW9XN891kCW6eagtuofyudZ2BkoxcYRJ0vcDXo7RoiXuf9nHaG4k/xwhAzTqe8hdO1ltWA==", + "license": "MIT", + "dependencies": { + "@turf/area": "7.3.1", + "@turf/bbox": "7.3.1", + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/explode": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/isolines": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/isolines/-/isolines-7.3.1.tgz", + "integrity": "sha512-TcwbTd7Z4BffYe1PtpXUtZvWCwTffta8VxqryGU30CbqKjNJYqrFbEQXS0mo4l3BEPPmT1lfMskUQ2g97O2MWQ==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/jsts": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/@turf/jsts/-/jsts-2.7.2.tgz", + "integrity": "sha512-zAezGlwWHPyU0zxwcX2wQY3RkRpwuoBmhhNE9HY9kWhFDkCxZ3aWK5URKwa/SWKJbj9aztO+8vtdiBA28KVJFg==", + "license": "(EDL-1.0 OR EPL-1.0)", + "dependencies": { + "jsts": "2.7.1" + } + }, + "node_modules/@turf/kinks": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/kinks/-/kinks-7.3.1.tgz", + "integrity": "sha512-gGXNrhlF7zvLwRX672S0Be7bmYjbZEoZYnOGN6RvhyBFSSLFIbne+I74I+lWRzAzG/NhAMBXma5TpB09iTH06Q==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/length": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/length/-/length-7.3.1.tgz", + "integrity": "sha512-QOr4qS3yi6qWIfQ/KLcy4rDLdemGCYpqz2YDh29R46seE+arSvlBI0KXvI36rPzgEMcUbQuVQyO65sOSqPaEjQ==", + "license": "MIT", + "dependencies": { + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/line-arc": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/line-arc/-/line-arc-7.3.1.tgz", + "integrity": "sha512-QSuVP0YWcfl76QjPb5Y2GJqXnziSJ2AuaJm5RKEFt5ELugXdEcHkRtydkGov+ZRPmI93jVmXoEE0UXwQx7aYHA==", + "license": "MIT", + "dependencies": { + "@turf/circle": "7.3.1", + "@turf/destination": "7.3.1", + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/line-chunk": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/line-chunk/-/line-chunk-7.3.1.tgz", + "integrity": "sha512-fbJw/7Qlqz0XRMz0TgtFUivFHr51+++ZUBrARgs3w/pogeAdkrcWKBbuT2cowEsUkXDHaQ7MMpmuV8Uteru1qw==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/length": "7.3.1", + "@turf/line-slice-along": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/line-intersect": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/line-intersect/-/line-intersect-7.3.1.tgz", + "integrity": "sha512-HFPH4Hi+rG7XZ5rijkYL5C9JGVKd6gz6TToShVfqOt/qgGY9/bLYQxymgum/MG7sRhIa8xcKff2d57JrIVuSWA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "sweepline-intersections": "^1.5.0", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/line-offset": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/line-offset/-/line-offset-7.3.1.tgz", + "integrity": "sha512-PyElfSyXETXcI8OKRsAJNdOcxlM718EG0d+b9zeO2uRztf2IlSb5w3lYiTIUSslEDA1gMQE31cJE8sAW40+nhg==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/line-overlap": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/line-overlap/-/line-overlap-7.3.1.tgz", + "integrity": "sha512-xIhTfPhJMwz57DvM+/JuzG2BUL/gR/pJfH6w+vofI3akej33LTR8b296h2dhcJjDixxprVVH062AD1Q3AGKyfg==", + "license": "MIT", + "dependencies": { + "@turf/boolean-point-on-line": "7.3.1", + "@turf/geojson-rbush": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/line-segment": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/nearest-point-on-line": "7.3.1", + "@types/geojson": "^7946.0.10", + "fast-deep-equal": "^3.1.3", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/line-segment": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/line-segment/-/line-segment-7.3.1.tgz", + "integrity": "sha512-hHz1fM2LigNKmnhyHDXtbRrkBqltH/lYEvhgSmv3laZ9PsEYL8jvA3o7+IhLM9B4KPa8N6VGim6ZR5YA5bhLvQ==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/line-slice": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/line-slice/-/line-slice-7.3.1.tgz", + "integrity": "sha512-bp1L4sc7ZOYC4fwxpfWu+IR/COvLFGm5mjbLPK8VBJYa+kUNrzNcB3QE3A8yFRjwPtlUTCm5fDMLSoGtiJcy2g==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/nearest-point-on-line": "7.3.1", + "@types/geojson": "^7946.0.10" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/line-slice-along": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/line-slice-along/-/line-slice-along-7.3.1.tgz", + "integrity": "sha512-RizIhPytHxEewCyUCSMrZ5a58sQev0kZ0jzAV/9iTzvGfRD1VU/RG2ThLpSEqXYKBBSty98rTeSlnwsvZpAraA==", + "license": "MIT", + "dependencies": { + "@turf/bearing": "7.3.1", + "@turf/destination": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/line-split": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/line-split/-/line-split-7.3.1.tgz", + "integrity": "sha512-Ee4NRN+eYKYX8vJDNvMpyZFjOntKFokQ/E8yFtKMcN++vG7RbnPOo2/ag6TMZaIHsahj4UR2yhqJbHTaB6Dp+g==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/geojson-rbush": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/line-intersect": "7.3.1", + "@turf/line-segment": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/nearest-point-on-line": "7.3.1", + "@turf/truncate": "7.3.1", + "@types/geojson": "^7946.0.10" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/line-to-polygon": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/line-to-polygon/-/line-to-polygon-7.3.1.tgz", + "integrity": "sha512-GL4fjbdYYjfOmwTu4dtllNHm18E7+hoXqyca2Rqb2ZzXj++NHvifJ9iYHUSdpV4/mkvVD3U2rU6jzNkjQeXIaA==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/mask": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/mask/-/mask-7.3.1.tgz", + "integrity": "sha512-rSNS6wNuBiaUR1aU7tobgkzHpot5v9GKCn+n5gQ3ad7KWqwwqLWfcCPeyHBWkWEoEwc2yfPqikMQugZbmxrorg==", + "license": "MIT", + "dependencies": { + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "polyclip-ts": "^0.16.8", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/meta": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/meta/-/meta-7.3.1.tgz", + "integrity": "sha512-NWsfOE5RVtWpLQNkfOF/RrYvLRPwwruxhZUV0UFIzHqfiRJ50aO9Y6uLY4bwCUe2TumLJQSR4yaoA72Rmr2mnQ==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/midpoint": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/midpoint/-/midpoint-7.3.1.tgz", + "integrity": "sha512-hx3eT9ut0Qyl8fyitCREp9l+v5Q4uBILht5+VKQS3p5eK2ijLEsKw4VikNZhh2rZ7bHGrs6obG5/P5ZqDTObiA==", + "license": "MIT", + "dependencies": { + "@turf/bearing": "7.3.1", + "@turf/destination": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/moran-index": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/moran-index/-/moran-index-7.3.1.tgz", + "integrity": "sha512-9t70AjBB0bycJWLVprqS7mtRU+Ha+U4ji5lkKzyg31ZWAr0IwuawY2VQ/ydsodFMLCqmIf8QbWsltV/I/bRdjQ==", + "license": "MIT", + "dependencies": { + "@turf/distance-weight": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/nearest-neighbor-analysis": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/nearest-neighbor-analysis/-/nearest-neighbor-analysis-7.3.1.tgz", + "integrity": "sha512-qwZON/7v1NbD1H1v3kTHJfLLml2/TNj5QQFRFBJiXRSCydMJT1sKEs5BwJe/9cBbmd0ln3gBWXCkG7Sk3sPgOQ==", + "license": "MIT", + "dependencies": { + "@turf/area": "7.3.1", + "@turf/bbox": "7.3.1", + "@turf/bbox-polygon": "7.3.1", + "@turf/centroid": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/nearest-point": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/nearest-point": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/nearest-point/-/nearest-point-7.3.1.tgz", + "integrity": "sha512-hLKGFzwAEop5z04X5BeurJvz0oVPHQX0rjeL3v83kgIjR/eavQucXKO3XkJBoF1AaT9Dv0mgB8rmj/qrwroWgg==", + "license": "MIT", + "dependencies": { + "@turf/clone": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/nearest-point-on-line": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/nearest-point-on-line/-/nearest-point-on-line-7.3.1.tgz", + "integrity": "sha512-FialyHfXXZWLayKQcUtdOtKv3ulOQ9FSI45kSmkDl8b96+VFWHX983Pc94tTrSTSg89+XX7MDr6gRl0yowmF4Q==", + "license": "MIT", + "dependencies": { + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/nearest-point-to-line": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/nearest-point-to-line/-/nearest-point-to-line-7.3.1.tgz", + "integrity": "sha512-7zvhE15vlKBW7F3gYmxZMrnsS2HhXIt0Mpdymy6Y1oMWAXrYIqSeHl1Y/h2CiDh0v91K1KJXf2WyRYacosWiNA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/point-to-line-distance": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/planepoint": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/planepoint/-/planepoint-7.3.1.tgz", + "integrity": "sha512-/DVTAZcOsSW54B9XDYUXyiL000vJ8WfONCF4FoM71VMeLS7PM3e+4W9gzN21q15XRn3nUftH12tJhqKEqDouvw==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/point-grid": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/point-grid/-/point-grid-7.3.1.tgz", + "integrity": "sha512-KqBlGgBzI/M7/awK25o9p8Q+mRjQDRU4mpHtqNzqNxgidk4JxnUnGybYTnsjp3n1Zid3yASv5kARJ4i/Jc5F7w==", + "license": "MIT", + "dependencies": { + "@turf/boolean-within": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/point-on-feature": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/point-on-feature/-/point-on-feature-7.3.1.tgz", + "integrity": "sha512-uX15wjujBMeMKAN7OLK4RV6KCLxsoQiFRB9kMtbTeZj13mDo+Bz5SyNN+M2AXqrdsQI9+4h0UTwu3EjcXj/nEw==", + "license": "MIT", + "dependencies": { + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/center": "7.3.1", + "@turf/explode": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/nearest-point": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/point-to-line-distance": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/point-to-line-distance/-/point-to-line-distance-7.3.1.tgz", + "integrity": "sha512-vynnX3zIMmJY633fyAIKnzlsmL7OBhbk05YhWVSjCKvSQV8C2xMA9pWaLFacn1xu4nfMSVDUaNOrcAqwubN9pg==", + "license": "MIT", + "dependencies": { + "@turf/bearing": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/nearest-point-on-line": "7.3.1", + "@turf/projection": "7.3.1", + "@turf/rhumb-bearing": "7.3.1", + "@turf/rhumb-distance": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/point-to-polygon-distance": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/point-to-polygon-distance/-/point-to-polygon-distance-7.3.1.tgz", + "integrity": "sha512-A2hTQjMKO2VEMdgOariICLCjt0BDc1wAQ7Mzqc4vFuol1/GlAed4JqyLg1zXuOVlZcojvXDk/XRuZwXDlRJkBA==", + "license": "MIT", + "dependencies": { + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/point-to-line-distance": "7.3.1", + "@turf/polygon-to-line": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/points-within-polygon": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/points-within-polygon/-/points-within-polygon-7.3.1.tgz", + "integrity": "sha512-tVcQVykc1vvSqz+l/PA4EKVWfMrGtA3ZUxDYBoD2tSaM79EpdTcY1BzfxT5O2582SQ0AdNFXDXRTf7VI6u/+2Q==", + "license": "MIT", + "dependencies": { + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/polygon-smooth": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/polygon-smooth/-/polygon-smooth-7.3.1.tgz", + "integrity": "sha512-CNi4SdpOycZRSBr4o0MlrFdC6x5xcXP6jKx2yXZf9FPrOWamHsDXa+NrywCOAPhgZKnBodRF6usKWudVMyPIgg==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/polygon-tangents": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/polygon-tangents/-/polygon-tangents-7.3.1.tgz", + "integrity": "sha512-XPLeCLQAcU2xco+3kS5Mp4AKmCKjOGzyZoC6oy8BuvHg1HaaEs0ZRzcmf0x17cq7bruhJ7n/QkcudnAueae5mg==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/boolean-within": "7.3.1", + "@turf/explode": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/nearest-point": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/polygon-to-line": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/polygon-to-line/-/polygon-to-line-7.3.1.tgz", + "integrity": "sha512-qTOFzn7SLQ0TcKBsPFAFYz7iiq34ijqinpjyr9fHQlFHRHeWzUXiWyIn5a2uOHazkdhHCEXNX8JPkt6hjdZ/fQ==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/polygonize": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/polygonize/-/polygonize-7.3.1.tgz", + "integrity": "sha512-BSamH4eDSbREtye/RZiIyt488KI/hO3+2FiDB8JUoHNESe3VNWk4KEy+sL6oqfhOZcRWndHtJ6MOi3HFptyJrw==", + "license": "MIT", + "dependencies": { + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/envelope": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/projection": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/projection/-/projection-7.3.1.tgz", + "integrity": "sha512-nDM3LG2j37B1tCpF4xL4rUBrQJcG585IRyDIxL2QEvP1LLv6dcm4fodw70HcGAj05Ux8bJr7IOXQXnobOJrlRA==", + "license": "MIT", + "dependencies": { + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/quadrat-analysis": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/quadrat-analysis/-/quadrat-analysis-7.3.1.tgz", + "integrity": "sha512-Kwqtih5CnijULGoTobS0pXdzh/Yr3iGatJcKks4IaxA4+hlJ6Z+Mj47QfKvUtl/IP3lZpVzezewJ51Y989YtVg==", + "license": "MIT", + "dependencies": { + "@turf/area": "7.3.1", + "@turf/bbox": "7.3.1", + "@turf/bbox-polygon": "7.3.1", + "@turf/centroid": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/point-grid": "7.3.1", + "@turf/random": "7.3.1", + "@turf/square-grid": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/random": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/random/-/random-7.3.1.tgz", + "integrity": "sha512-Iruica0gfdAuuqWG3SLe1MQOEP4IOGelPp81Cu552AamhHJmkEZCaiis2n28qdOlAbDs1NJZeJhRFNkiopiy+Q==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/rectangle-grid": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/rectangle-grid/-/rectangle-grid-7.3.1.tgz", + "integrity": "sha512-3/fwd1dzeGApxGXAzyVINFylmn8trYTPLG6jtqOgriAdiHPMTtPqSW58wpScC43oKbK3Bps9dSZ43jvcbrfGxw==", + "license": "MIT", + "dependencies": { + "@turf/boolean-intersects": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/rewind": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/rewind/-/rewind-7.3.1.tgz", + "integrity": "sha512-gD2TGPNq3SE6IlpDwkVHQthZ2U2MElh6X4Vfld3K7VsBHJv4eBct6OOgSWZLkVVPHuWNlVFTNtcRh2LAznMtgw==", + "license": "MIT", + "dependencies": { + "@turf/boolean-clockwise": "7.3.1", + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/rhumb-bearing": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/rhumb-bearing/-/rhumb-bearing-7.3.1.tgz", + "integrity": "sha512-GA/EUSOMapLp6qK5kOX+PkFg2MMUHzUSm/jVezv6Fted0dAlCgXHOrKgLm0tN8PqbH7Oj9xQhv9+3/1ze7W8YA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/rhumb-destination": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/rhumb-destination/-/rhumb-destination-7.3.1.tgz", + "integrity": "sha512-HjtAFr5DTISUn9b4oaZpX79tYl72r4EyAj40HKwjQeV6KkwIe5/h4zryOSEpnvAK2Gnkmu1GxYeTGfM5z3J9JA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/rhumb-distance": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/rhumb-distance/-/rhumb-distance-7.3.1.tgz", + "integrity": "sha512-9ZvXU0ii2aywdphLhiawl3uxMEHucMmXCBiRj3WhmssTY9CZkFii9iImbJEqz5glxh6/gzXDcz1CCFQUdNP2xA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/sample": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/sample/-/sample-7.3.1.tgz", + "integrity": "sha512-s9IkXrrtaHRllgk9X2tmg8+SJKLG6orQwf0p1wZX8WxnHXvmnHaju465A3nmtGGVDI/RSD8KwU9aqPcc4AinNw==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/sector": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/sector/-/sector-7.3.1.tgz", + "integrity": "sha512-3BYJk7pQaqVr1Ji1ors6FUnhCJVHuobNf4bYW2yAUW1rxL+snuo6aTCsu39hpkwLj4BBknYt5w4MIOy5b8+QKg==", + "license": "MIT", + "dependencies": { + "@turf/circle": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/line-arc": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/shortest-path": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/shortest-path/-/shortest-path-7.3.1.tgz", + "integrity": "sha512-B0j6MoTSeGw1inRJPfj+6lU4WVXBNFAafqs/BkccScnCHLLK+vMnsOkyQoDX2vdZnhPTEaGj7TEL1SIjV6IMgA==", + "license": "MIT", + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/bbox-polygon": "7.3.1", + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/clean-coords": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/transform-scale": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/simplify": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/simplify/-/simplify-7.3.1.tgz", + "integrity": "sha512-8LRITQAyNAdvVInjm8pal3J7ZAZZBYrYd5oApXqHlIFK7gEiE21Hx9CZyog6AHDjxZCinwnEoGkzDxORh/mNMg==", + "license": "MIT", + "dependencies": { + "@turf/clean-coords": "7.3.1", + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/square": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/square/-/square-7.3.1.tgz", + "integrity": "sha512-LvMkII6bbHaFHp67jI029xHjWFK3pnqwF8c2pUNU+0dL+45KgrO2jaFTnNQdsjexPymI+uaNLlG809Y0aGGQlw==", + "license": "MIT", + "dependencies": { + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/square-grid": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/square-grid/-/square-grid-7.3.1.tgz", + "integrity": "sha512-WYCX8+nrqHyAhKBSBHFp1eU1gWrcojz9uVvhCbDO8NO14SLHowzWOgB61Gv8KlLXCUBjDr+rYWCt3ymyPzU5TA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/rectangle-grid": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/standard-deviational-ellipse": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/standard-deviational-ellipse/-/standard-deviational-ellipse-7.3.1.tgz", + "integrity": "sha512-u9ojpWyv3rnFioYZyya6VXVDrRPYymNROVKwGqnQzffYE1MdxhJ6ik/CvdcChzCNvSNVBJQUvnjjPq2C2uOsLA==", + "license": "MIT", + "dependencies": { + "@turf/center-mean": "7.3.1", + "@turf/ellipse": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/points-within-polygon": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/tag": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/tag/-/tag-7.3.1.tgz", + "integrity": "sha512-Y7G2EWm0/j78ss5wCnjGWKfmPbXw9yKJFg93EuMnwggIsDfKdQi/vdUInjQ0462RIQA87StlydPG09X/8bquwQ==", + "license": "MIT", + "dependencies": { + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/tesselate": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/tesselate/-/tesselate-7.3.1.tgz", + "integrity": "sha512-iJnatp9RcJvyffBjqJaw5GbKE/PQosT8DH2kgG7pv4Re0xl3h/QvCjvTlCTEmJ5cNY4geZVKUXDvkkCkgQQVuA==", + "license": "MIT", + "dependencies": { + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "earcut": "^2.2.4", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } }, - "node_modules/@rollup/rollup-linux-s390x-gnu": { - "version": "4.55.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.55.1.tgz", - "integrity": "sha512-/0PenBCmqM4ZUd0190j7J0UsQ/1nsi735iPRakO8iPciE7BQ495Y6msPzaOmvx0/pn+eJVVlZrNrSh4WSYLxNg==", - "cpu": [ - "s390x" - ], - "dev": true, + "node_modules/@turf/tin": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/tin/-/tin-7.3.1.tgz", + "integrity": "sha512-pDtHE8rLXvV4zAC9mWmwToDDda2ZTty8IZqZIoUqTnlf6AJjzF7TJrhoE3a+zukRTUI1wowTFqe2NvwgNX0yew==", "license": "MIT", - "optional": true, - "os": [ - "linux" - ] + "dependencies": { + "@turf/helpers": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } }, - "node_modules/@rollup/rollup-linux-x64-gnu": { - "version": "4.55.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.55.1.tgz", - "integrity": "sha512-a8G4wiQxQG2BAvo+gU6XrReRRqj+pLS2NGXKm8io19goR+K8lw269eTrPkSdDTALwMmJp4th2Uh0D8J9bEV1vg==", - "cpu": [ - "x64" - ], + "node_modules/@turf/transform-rotate": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/transform-rotate/-/transform-rotate-7.3.1.tgz", + "integrity": "sha512-KAYebOkk7IT2j7S8M+ZxDAmyqeni9ZZGU9ouD6mvd/hTpDOlGG+ORRmg312RxG0NiThzCHLyeG1Nea1nEud6bg==", "license": "MIT", - "optional": true, - "os": [ - "linux" - ] + "dependencies": { + "@turf/centroid": "7.3.1", + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/rhumb-bearing": "7.3.1", + "@turf/rhumb-destination": "7.3.1", + "@turf/rhumb-distance": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } }, - "node_modules/@rollup/rollup-linux-x64-musl": { - "version": "4.55.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.55.1.tgz", - "integrity": "sha512-bD+zjpFrMpP/hqkfEcnjXWHMw5BIghGisOKPj+2NaNDuVT+8Ds4mPf3XcPHuat1tz89WRL+1wbcxKY3WSbiT7w==", - "cpu": [ - "x64" - ], - "dev": true, + "node_modules/@turf/transform-scale": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/transform-scale/-/transform-scale-7.3.1.tgz", + "integrity": "sha512-e8jBSWEn0BMxG0HR8ZMvkHgBgdwNrFRzbhy8DqQwZDgUN59fMeWGbjX5QR5Exl2gZBPaBXkgbDgEhh/JD3kYhw==", "license": "MIT", - "optional": true, - "os": [ - "linux" - ] + "dependencies": { + "@turf/bbox": "7.3.1", + "@turf/center": "7.3.1", + "@turf/centroid": "7.3.1", + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/rhumb-bearing": "7.3.1", + "@turf/rhumb-destination": "7.3.1", + "@turf/rhumb-distance": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } }, - "node_modules/@rollup/rollup-openbsd-x64": { - "version": "4.55.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.55.1.tgz", - "integrity": "sha512-eLXw0dOiqE4QmvikfQ6yjgkg/xDM+MdU9YJuP4ySTibXU0oAvnEWXt7UDJmD4UkYialMfOGFPJnIHSe/kdzPxg==", - "cpu": [ - "x64" - ], - "dev": true, + "node_modules/@turf/transform-translate": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/transform-translate/-/transform-translate-7.3.1.tgz", + "integrity": "sha512-yeaW1EqfuuY4l5VBWSsItglaZ9qdTFD0QEIUW1ooOYuQvtKQ2MTKrcQIKLXZckxQrrNq4TXsZDaBbFs+U1wtcQ==", "license": "MIT", - "optional": true, - "os": [ - "openbsd" - ] + "dependencies": { + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/rhumb-destination": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } }, - "node_modules/@rollup/rollup-openharmony-arm64": { - "version": "4.55.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.55.1.tgz", - "integrity": "sha512-xzm44KgEP11te3S2HCSyYf5zIzWmx3n8HDCc7EE59+lTcswEWNpvMLfd9uJvVX8LCg9QWG67Xt75AuHn4vgsXw==", - "cpu": [ - "arm64" - ], - "dev": true, + "node_modules/@turf/triangle-grid": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/triangle-grid/-/triangle-grid-7.3.1.tgz", + "integrity": "sha512-lhZyqnQC/M8x8DgQURHNZP/HaJIqrL5We5ZvzJBX+lrH2u4DO831awJcuDniRuJ5e0QE5n4yMsBJO77KMNdKfw==", "license": "MIT", - "optional": true, - "os": [ - "openharmony" - ] + "dependencies": { + "@turf/distance": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/intersect": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } }, - "node_modules/@rollup/rollup-win32-arm64-msvc": { - "version": "4.55.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.55.1.tgz", - "integrity": "sha512-yR6Bl3tMC/gBok5cz/Qi0xYnVbIxGx5Fcf/ca0eB6/6JwOY+SRUcJfI0OpeTpPls7f194as62thCt/2BjxYN8g==", - "cpu": [ - "arm64" - ], - "dev": true, + "node_modules/@turf/truncate": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/truncate/-/truncate-7.3.1.tgz", + "integrity": "sha512-rcXHM2m17hyKoW1dJpOvTgUUWFOKluTKKsoLmhEE6aRAYwtuVetkcInt4qBtS1bv7MaL//glbvq0kdEGR0YaOA==", "license": "MIT", - "optional": true, - "os": [ - "win32" - ] + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } }, - "node_modules/@rollup/rollup-win32-ia32-msvc": { - "version": "4.55.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.55.1.tgz", - "integrity": "sha512-3fZBidchE0eY0oFZBnekYCfg+5wAB0mbpCBuofh5mZuzIU/4jIVkbESmd2dOsFNS78b53CYv3OAtwqkZZmU5nA==", - "cpu": [ - "ia32" - ], - "dev": true, + "node_modules/@turf/turf": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/turf/-/turf-7.3.1.tgz", + "integrity": "sha512-0uKkNnM6Bo6cIzZcJ6wQ+FjFioTFXWS3woGDvQ5R7EPehNfdr4HTS39m1seE+HdI8lGItMZehb6fb0jtjP4Clg==", + "license": "MIT", + "dependencies": { + "@turf/along": "7.3.1", + "@turf/angle": "7.3.1", + "@turf/area": "7.3.1", + "@turf/bbox": "7.3.1", + "@turf/bbox-clip": "7.3.1", + "@turf/bbox-polygon": "7.3.1", + "@turf/bearing": "7.3.1", + "@turf/bezier-spline": "7.3.1", + "@turf/boolean-clockwise": "7.3.1", + "@turf/boolean-concave": "7.3.1", + "@turf/boolean-contains": "7.3.1", + "@turf/boolean-crosses": "7.3.1", + "@turf/boolean-disjoint": "7.3.1", + "@turf/boolean-equal": "7.3.1", + "@turf/boolean-intersects": "7.3.1", + "@turf/boolean-overlap": "7.3.1", + "@turf/boolean-parallel": "7.3.1", + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/boolean-point-on-line": "7.3.1", + "@turf/boolean-touches": "7.3.1", + "@turf/boolean-valid": "7.3.1", + "@turf/boolean-within": "7.3.1", + "@turf/buffer": "7.3.1", + "@turf/center": "7.3.1", + "@turf/center-mean": "7.3.1", + "@turf/center-median": "7.3.1", + "@turf/center-of-mass": "7.3.1", + "@turf/centroid": "7.3.1", + "@turf/circle": "7.3.1", + "@turf/clean-coords": "7.3.1", + "@turf/clone": "7.3.1", + "@turf/clusters": "7.3.1", + "@turf/clusters-dbscan": "7.3.1", + "@turf/clusters-kmeans": "7.3.1", + "@turf/collect": "7.3.1", + "@turf/combine": "7.3.1", + "@turf/concave": "7.3.1", + "@turf/convex": "7.3.1", + "@turf/destination": "7.3.1", + "@turf/difference": "7.3.1", + "@turf/dissolve": "7.3.1", + "@turf/distance": "7.3.1", + "@turf/distance-weight": "7.3.1", + "@turf/ellipse": "7.3.1", + "@turf/envelope": "7.3.1", + "@turf/explode": "7.3.1", + "@turf/flatten": "7.3.1", + "@turf/flip": "7.3.1", + "@turf/geojson-rbush": "7.3.1", + "@turf/great-circle": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/hex-grid": "7.3.1", + "@turf/interpolate": "7.3.1", + "@turf/intersect": "7.3.1", + "@turf/invariant": "7.3.1", + "@turf/isobands": "7.3.1", + "@turf/isolines": "7.3.1", + "@turf/kinks": "7.3.1", + "@turf/length": "7.3.1", + "@turf/line-arc": "7.3.1", + "@turf/line-chunk": "7.3.1", + "@turf/line-intersect": "7.3.1", + "@turf/line-offset": "7.3.1", + "@turf/line-overlap": "7.3.1", + "@turf/line-segment": "7.3.1", + "@turf/line-slice": "7.3.1", + "@turf/line-slice-along": "7.3.1", + "@turf/line-split": "7.3.1", + "@turf/line-to-polygon": "7.3.1", + "@turf/mask": "7.3.1", + "@turf/meta": "7.3.1", + "@turf/midpoint": "7.3.1", + "@turf/moran-index": "7.3.1", + "@turf/nearest-neighbor-analysis": "7.3.1", + "@turf/nearest-point": "7.3.1", + "@turf/nearest-point-on-line": "7.3.1", + "@turf/nearest-point-to-line": "7.3.1", + "@turf/planepoint": "7.3.1", + "@turf/point-grid": "7.3.1", + "@turf/point-on-feature": "7.3.1", + "@turf/point-to-line-distance": "7.3.1", + "@turf/point-to-polygon-distance": "7.3.1", + "@turf/points-within-polygon": "7.3.1", + "@turf/polygon-smooth": "7.3.1", + "@turf/polygon-tangents": "7.3.1", + "@turf/polygon-to-line": "7.3.1", + "@turf/polygonize": "7.3.1", + "@turf/projection": "7.3.1", + "@turf/quadrat-analysis": "7.3.1", + "@turf/random": "7.3.1", + "@turf/rectangle-grid": "7.3.1", + "@turf/rewind": "7.3.1", + "@turf/rhumb-bearing": "7.3.1", + "@turf/rhumb-destination": "7.3.1", + "@turf/rhumb-distance": "7.3.1", + "@turf/sample": "7.3.1", + "@turf/sector": "7.3.1", + "@turf/shortest-path": "7.3.1", + "@turf/simplify": "7.3.1", + "@turf/square": "7.3.1", + "@turf/square-grid": "7.3.1", + "@turf/standard-deviational-ellipse": "7.3.1", + "@turf/tag": "7.3.1", + "@turf/tesselate": "7.3.1", + "@turf/tin": "7.3.1", + "@turf/transform-rotate": "7.3.1", + "@turf/transform-scale": "7.3.1", + "@turf/transform-translate": "7.3.1", + "@turf/triangle-grid": "7.3.1", + "@turf/truncate": "7.3.1", + "@turf/union": "7.3.1", + "@turf/unkink-polygon": "7.3.1", + "@turf/voronoi": "7.3.1", + "@types/geojson": "^7946.0.10", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } + }, + "node_modules/@turf/union": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/union/-/union-7.3.1.tgz", + "integrity": "sha512-Fk8HvP2gRrRJz8xefeoFJJUeLwhih3HoPPKlqaDf/6L43jwAzBD6BPu59+AwRXOlaZeOUMNMGzgSgx0KKrBwBg==", "license": "MIT", - "optional": true, - "os": [ - "win32" - ] + "dependencies": { + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "polyclip-ts": "^0.16.8", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } }, - "node_modules/@rollup/rollup-win32-x64-gnu": { - "version": "4.55.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.55.1.tgz", - "integrity": "sha512-xGGY5pXj69IxKb4yv/POoocPy/qmEGhimy/FoTpTSVju3FYXUQQMFCaZZXJVidsmGxRioZAwpThl/4zX41gRKg==", - "cpu": [ - "x64" - ], - "dev": true, + "node_modules/@turf/unkink-polygon": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/unkink-polygon/-/unkink-polygon-7.3.1.tgz", + "integrity": "sha512-6NVFkCpJUT2P4Yf3z/FI2uGDXqVdEqZqKGl2hYitmH7mNiKhU4bAvvcw7nCSfNG3sUyNhibbtOEopYMRgwimPw==", "license": "MIT", - "optional": true, - "os": [ - "win32" - ] + "dependencies": { + "@turf/area": "7.3.1", + "@turf/boolean-point-in-polygon": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/meta": "7.3.1", + "@types/geojson": "^7946.0.10", + "rbush": "^3.0.1", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } }, - "node_modules/@rollup/rollup-win32-x64-msvc": { - "version": "4.55.1", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.55.1.tgz", - "integrity": "sha512-SPEpaL6DX4rmcXtnhdrQYgzQ5W2uW3SCJch88lB2zImhJRhIIK44fkUrgIV/Q8yUNfw5oyZ5vkeQsZLhCb06lw==", - "cpu": [ - "x64" - ], + "node_modules/@turf/voronoi": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/@turf/voronoi/-/voronoi-7.3.1.tgz", + "integrity": "sha512-yS+0EDwSIOizEXI+05qixw/OGZalpfsz9xzBWbCBA3Gu2boLMXErFZ73qzfu39Vwk+ILbu5em0p+VhULBzvH9w==", "license": "MIT", - "optional": true, - "os": [ - "win32" - ] + "dependencies": { + "@turf/clone": "7.3.1", + "@turf/helpers": "7.3.1", + "@turf/invariant": "7.3.1", + "@types/d3-voronoi": "^1.1.12", + "@types/geojson": "^7946.0.10", + "d3-voronoi": "1.1.2", + "tslib": "^2.8.1" + }, + "funding": { + "url": "https://opencollective.com/turf" + } }, "node_modules/@types/aws-lambda": { "version": "8.10.147", @@ -6360,6 +8387,12 @@ "@types/node": "*" } }, + "node_modules/@types/d3-voronoi": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/@types/d3-voronoi/-/d3-voronoi-1.1.12.tgz", + "integrity": "sha512-DauBl25PKZZ0WVJr42a6CNvI6efsdzofl9sajqZr2Gf5Gu733WkDdUGiPkUHXiUvYGzNNlFQde2wdZdfQPG+yw==", + "license": "MIT" + }, "node_modules/@types/deep-eql": { "version": "4.0.2", "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz", @@ -6381,6 +8414,12 @@ "dev": true, "license": "MIT" }, + "node_modules/@types/geojson": { + "version": "7946.0.16", + "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz", + "integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==", + "license": "MIT" + }, "node_modules/@types/inquirer": { "version": "9.0.9", "resolved": "https://registry.npmjs.org/@types/inquirer/-/inquirer-9.0.9.tgz", @@ -7642,6 +9681,18 @@ "dev": true, "license": "MIT" }, + "node_modules/concaveman": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/concaveman/-/concaveman-1.2.1.tgz", + "integrity": "sha512-PwZYKaM/ckQSa8peP5JpVr7IMJ4Nn/MHIaWUjP4be+KoZ7Botgs8seAZGpmaOM+UZXawcdYRao/px9ycrCihHw==", + "license": "ISC", + "dependencies": { + "point-in-polygon": "^1.1.0", + "rbush": "^3.0.1", + "robust-predicates": "^2.0.4", + "tinyqueue": "^2.0.3" + } + }, "node_modules/content-disposition": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.1.tgz", @@ -7905,6 +9956,27 @@ "node": ">=20" } }, + "node_modules/d3-array": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-1.2.4.tgz", + "integrity": "sha512-KHW6M86R+FUPYGb3R5XiYjXPq7VzwxZ22buHhAEVG5ztoEcZZMLov530mmccaqA1GghZArjQV46fuc8kUqhhHw==", + "license": "BSD-3-Clause" + }, + "node_modules/d3-geo": { + "version": "1.7.1", + "resolved": "https://registry.npmjs.org/d3-geo/-/d3-geo-1.7.1.tgz", + "integrity": "sha512-O4AempWAr+P5qbk2bC2FuN/sDW4z+dN2wDf9QV3bxQt4M5HfOEeXLgJ/UKQW0+o1Dj8BE+L5kiDbdWUMjsmQpw==", + "license": "BSD-3-Clause", + "dependencies": { + "d3-array": "1" + } + }, + "node_modules/d3-voronoi": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/d3-voronoi/-/d3-voronoi-1.1.2.tgz", + "integrity": "sha512-RhGS1u2vavcO7ay7ZNAPo4xeDh/VYeGof3x5ZLJBQgYhLegxr3s5IykvWmJ94FTU6mcbtp4sloqZ54mP6R4Utw==", + "license": "BSD-3-Clause" + }, "node_modules/debug": { "version": "4.4.3", "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", @@ -8010,6 +10082,12 @@ "node": ">= 0.4" } }, + "node_modules/earcut": { + "version": "2.2.4", + "resolved": "https://registry.npmjs.org/earcut/-/earcut-2.2.4.tgz", + "integrity": "sha512-/pjZsA1b4RPHbeWZQn66SWS8nZZWLQQ23oE3Eam7aroEFGEvwKAsJfZ9ytiEMycfzXWpca4FA9QIOehf7PocBQ==", + "license": "ISC" + }, "node_modules/eastasianwidth": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", @@ -9124,6 +11202,39 @@ "node": ">=6.9.0" } }, + "node_modules/geojson-equality-ts": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/geojson-equality-ts/-/geojson-equality-ts-1.0.2.tgz", + "integrity": "sha512-h3Ryq+0mCSN/7yLs0eDgrZhvc9af23o/QuC4aTiuuzP/MRCtd6mf5rLsLRY44jX0RPUfM8c4GqERQmlUxPGPoQ==", + "license": "MIT", + "dependencies": { + "@types/geojson": "^7946.0.14" + } + }, + "node_modules/geojson-polygon-self-intersections": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/geojson-polygon-self-intersections/-/geojson-polygon-self-intersections-1.2.2.tgz", + "integrity": "sha512-6XRNF4CsRHYmR9z5YuIk5f/aOototnDf0dgMqYGcS7y1l57ttt6MAIAxl3rXyas6lq1HEbTuLMh4PgvO+OV42w==", + "license": "MIT", + "dependencies": { + "rbush": "^2.0.1" + } + }, + "node_modules/geojson-polygon-self-intersections/node_modules/quickselect": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/quickselect/-/quickselect-1.1.1.tgz", + "integrity": "sha512-qN0Gqdw4c4KGPsBOQafj6yj/PA6c/L63f6CaZ/DCF/xF4Esu3jVmKLUDYxghFx8Kb/O7y9tI7x2RjTSXwdK1iQ==", + "license": "ISC" + }, + "node_modules/geojson-polygon-self-intersections/node_modules/rbush": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/rbush/-/rbush-2.0.2.tgz", + "integrity": "sha512-XBOuALcTm+O/H8G90b6pzu6nX6v2zCKiFG4BJho8a+bY6AER6t8uQUZdi5bomQc0AprCWhEGa7ncAbbRap0bRA==", + "license": "MIT", + "dependencies": { + "quickselect": "^1.0.1" + } + }, "node_modules/get-caller-file": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", @@ -10218,6 +12329,15 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/jsts": { + "version": "2.7.1", + "resolved": "https://registry.npmjs.org/jsts/-/jsts-2.7.1.tgz", + "integrity": "sha512-x2wSZHEBK20CY+Wy+BPE7MrFQHW6sIsdaGUMEqmGAio+3gFzQaBYPwLRonUfQf9Ak8pBieqj9tUofX1+WtAEIg==", + "license": "(EDL-1.0 OR EPL-1.0)", + "engines": { + "node": ">= 12" + } + }, "node_modules/keyv": { "version": "4.5.4", "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", @@ -11383,6 +13503,27 @@ "node": ">=18" } }, + "node_modules/point-in-polygon": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/point-in-polygon/-/point-in-polygon-1.1.0.tgz", + "integrity": "sha512-3ojrFwjnnw8Q9242TzgXuTD+eKiutbzyslcq1ydfu82Db2y+Ogbmyrkpv0Hgj31qwT3lbS9+QAAO/pIQM35XRw==", + "license": "MIT" + }, + "node_modules/point-in-polygon-hao": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/point-in-polygon-hao/-/point-in-polygon-hao-1.2.4.tgz", + "integrity": "sha512-x2pcvXeqhRHlNRdhLs/tgFapAbSSe86wa/eqmj1G6pWftbEs5aVRJhRGM6FYSUERKu0PjekJzMq0gsI2XyiclQ==", + "license": "MIT", + "dependencies": { + "robust-predicates": "^3.0.2" + } + }, + "node_modules/point-in-polygon-hao/node_modules/robust-predicates": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/robust-predicates/-/robust-predicates-3.0.2.tgz", + "integrity": "sha512-IXgzBWvWQwE6PrDI05OvmXUIruQTcoMDzRsOd5CDvHCVLcLHMTSYvOK5Cm46kWqlV3yAbuSpBZdJ5oP5OUoStg==", + "license": "Unlicense" + }, "node_modules/polite-json": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/polite-json/-/polite-json-5.0.0.tgz", @@ -11396,6 +13537,16 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/polyclip-ts": { + "version": "0.16.8", + "resolved": "https://registry.npmjs.org/polyclip-ts/-/polyclip-ts-0.16.8.tgz", + "integrity": "sha512-JPtKbDRuPEuAjuTdhR62Gph7Is2BS1Szx69CFOO3g71lpJDFo78k4tFyi+qFOMVPePEzdSKkpGU3NBXPHHjvKQ==", + "license": "MIT", + "dependencies": { + "bignumber.js": "^9.1.0", + "splaytree-ts": "^1.0.2" + } + }, "node_modules/postcss": { "version": "8.5.6", "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", @@ -11564,6 +13715,12 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/quickselect": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/quickselect/-/quickselect-2.0.0.tgz", + "integrity": "sha512-RKJ22hX8mHe3Y6wH/N3wCM6BWtjaxIyyUIkpHOvfFnxdI4yD4tBXEBKSbriGujF6jnSVkJrffuo6vxACiSSxIw==", + "license": "ISC" + }, "node_modules/range-parser": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", @@ -11588,6 +13745,15 @@ "node": ">= 0.10" } }, + "node_modules/rbush": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/rbush/-/rbush-3.0.1.tgz", + "integrity": "sha512-XRaVO0YecOpEuIvbhbpTrZgoiI6xBlz6hnlr6EHhd+0x9ase6EmeN+hdwwUaJvLcsFFQ8iWVF1GAK1yB0BWi0w==", + "license": "MIT", + "dependencies": { + "quickselect": "^2.0.0" + } + }, "node_modules/readable-stream": { "version": "3.6.2", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", @@ -11899,6 +14065,12 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/robust-predicates": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/robust-predicates/-/robust-predicates-2.0.4.tgz", + "integrity": "sha512-l4NwboJM74Ilm4VKfbAtFeGq7aEjWL+5kVFcmgFA2MrdnQWx9iE/tUGvxY5HyMI7o/WpSIUFLbC5fbeaHgSCYg==", + "license": "Unlicense" + }, "node_modules/rollup": { "version": "4.55.1", "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.55.1.tgz", @@ -12207,6 +14379,12 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/skmeans": { + "version": "0.9.7", + "resolved": "https://registry.npmjs.org/skmeans/-/skmeans-0.9.7.tgz", + "integrity": "sha512-hNj1/oZ7ygsfmPZ7ZfN5MUBRoGg1gtpnImuJBgLO0ljQ67DtJuiQaiYdS4lUA6s0KCwnPhGivtC/WRwIZLkHyg==", + "license": "MIT" + }, "node_modules/slash": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-2.0.0.tgz", @@ -12267,6 +14445,12 @@ "node": ">=0.10.0" } }, + "node_modules/splaytree-ts": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/splaytree-ts/-/splaytree-ts-1.0.2.tgz", + "integrity": "sha512-0kGecIZNIReCSiznK3uheYB8sbstLjCZLiwcQwbmLhgHJj2gz6OnSPkVzJQCMnmEz1BQ4gPK59ylhBoEWOhGNA==", + "license": "BDS-3-Clause" + }, "node_modules/stackback": { "version": "0.0.2", "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", @@ -12474,6 +14658,15 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/sweepline-intersections": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/sweepline-intersections/-/sweepline-intersections-1.5.0.tgz", + "integrity": "sha512-AoVmx72QHpKtItPu72TzFL+kcYjd67BPLDoR0LarIk+xyaRg+pDTMFXndIEvZf9xEKnJv6JdhgRMnocoG0D3AQ==", + "license": "MIT", + "dependencies": { + "tinyqueue": "^2.0.0" + } + }, "node_modules/sync-content": { "version": "2.0.3", "resolved": "https://registry.npmjs.org/sync-content/-/sync-content-2.0.3.tgz", @@ -12644,6 +14837,12 @@ "node": "^18.0.0 || >=20.0.0" } }, + "node_modules/tinyqueue": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/tinyqueue/-/tinyqueue-2.0.3.tgz", + "integrity": "sha512-ppJZNDuKGgxzkHihX8v9v9G5f+18gzaTfrukGrq6ueg0lmH4nqVnA2IPG0AEH3jKEk2GRJCUhDoqpoiw3PHLBA==", + "license": "ISC" + }, "node_modules/tinyrainbow": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz", @@ -12703,6 +14902,44 @@ "node": ">=0.6" } }, + "node_modules/topojson-client": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/topojson-client/-/topojson-client-3.1.0.tgz", + "integrity": "sha512-605uxS6bcYxGXw9qi62XyrV6Q3xwbndjachmNxu8HWTtVPxZfEJN9fd/SZS1Q54Sn2y0TMyMxFj/cJINqGHrKw==", + "license": "ISC", + "dependencies": { + "commander": "2" + }, + "bin": { + "topo2geo": "bin/topo2geo", + "topomerge": "bin/topomerge", + "topoquantize": "bin/topoquantize" + } + }, + "node_modules/topojson-client/node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "license": "MIT" + }, + "node_modules/topojson-server": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/topojson-server/-/topojson-server-3.0.1.tgz", + "integrity": "sha512-/VS9j/ffKr2XAOjlZ9CgyyeLmgJ9dMwq6Y0YEON8O7p/tGGk+dCWnrE03zEdu7i4L7YsFZLEPZPzCvcB7lEEXw==", + "license": "ISC", + "dependencies": { + "commander": "2" + }, + "bin": { + "geo2topo": "bin/geo2topo" + } + }, + "node_modules/topojson-server/node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "license": "MIT" + }, "node_modules/tr46": { "version": "0.0.3", "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", @@ -12791,7 +15028,6 @@ "version": "2.8.1", "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", - "dev": true, "license": "0BSD" }, "node_modules/type-check": { diff --git a/package.json b/package.json index 89b28f4..0f28153 100644 --- a/package.json +++ b/package.json @@ -85,6 +85,7 @@ "@opentelemetry/sdk-node": "^0.56.0", "@opentelemetry/sdk-trace-base": "^1.30.1", "@opentelemetry/semantic-conventions": "^1.30.1", + "@turf/turf": "^7.3.1", "zod": "^3.25.42" }, "tshy": { diff --git a/server.json b/server.json index 8ea0156..a78fa84 100644 --- a/server.json +++ b/server.json @@ -6,13 +6,13 @@ "url": "https://github.com/mapbox/mcp-server", "source": "github" }, - "version": "0.8.0", + "version": "0.8.1", "packages": [ { "registryType": "npm", "registryBaseUrl": "https://registry.npmjs.org", "runtimeHint": "npx", - "version": "0.8.0", + "version": "0.8.1", "identifier": "@mapbox/mcp-server", "transport": { "type": "stdio" diff --git a/src/tools/distance-tool/DistanceTool.input.schema.ts b/src/tools/distance-tool/DistanceTool.input.schema.ts new file mode 100644 index 0000000..224d0d2 --- /dev/null +++ b/src/tools/distance-tool/DistanceTool.input.schema.ts @@ -0,0 +1,34 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; + +/** + * Coordinate object schema with longitude and latitude + */ +const CoordinateSchema = z.object({ + longitude: z.number().min(-180).max(180).describe('Longitude: -180 to 180'), + latitude: z.number().min(-90).max(90).describe('Latitude: -90 to 90') +}); + +/** + * Input schema for DistanceTool + */ +export const DistanceInputSchema = z.object({ + from: CoordinateSchema.describe( + 'Starting coordinate with longitude and latitude' + ), + to: CoordinateSchema.describe( + 'Ending coordinate with longitude and latitude' + ), + units: z + .enum(['kilometers', 'miles', 'meters', 'feet', 'nauticalmiles']) + .optional() + .default('kilometers') + .describe('Unit of measurement for distance') +}); + +/** + * Type inference for DistanceInput + */ +export type DistanceInput = z.infer; diff --git a/src/tools/distance-tool/DistanceTool.output.schema.ts b/src/tools/distance-tool/DistanceTool.output.schema.ts new file mode 100644 index 0000000..15052b4 --- /dev/null +++ b/src/tools/distance-tool/DistanceTool.output.schema.ts @@ -0,0 +1,29 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Output schema for DistanceTool + */ +export const DistanceOutputSchema = z.object({ + distance: z.number().describe('Calculated distance between points'), + units: z.string().describe('Unit of measurement'), + from: z + .object({ + longitude: z.number(), + latitude: z.number() + }) + .describe('Starting coordinate'), + to: z + .object({ + longitude: z.number(), + latitude: z.number() + }) + .describe('Ending coordinate') +}); + +/** + * Type inference for DistanceOutput + */ +export type DistanceOutput = z.infer; diff --git a/src/tools/distance-tool/DistanceTool.ts b/src/tools/distance-tool/DistanceTool.ts new file mode 100644 index 0000000..10ec8b4 --- /dev/null +++ b/src/tools/distance-tool/DistanceTool.ts @@ -0,0 +1,120 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { distance as turfDistance } from '@turf/turf'; +import { context, SpanStatusCode, trace } from '@opentelemetry/api'; +import { createLocalToolExecutionContext } from '../../utils/tracing.js'; +import { BaseTool } from '../BaseTool.js'; +import { DistanceInputSchema } from './DistanceTool.input.schema.js'; +import { + DistanceOutputSchema, + type DistanceOutput +} from './DistanceTool.output.schema.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; + +/** + * DistanceTool - Calculate distance between two geographic coordinates + * + * This is an offline tool that performs local calculations without making API calls. + * Uses the Haversine formula to calculate great-circle distance on Earth's surface. + */ +export class DistanceTool extends BaseTool< + typeof DistanceInputSchema, + typeof DistanceOutputSchema +> { + readonly name = 'distance_tool'; + readonly description = + 'Calculate the distance between two geographic coordinates. ' + + 'Supports various units including kilometers, miles, meters, feet, and nautical miles. ' + + 'Uses the Haversine formula for accurate great-circle distance calculations. ' + + 'This tool works offline without requiring API calls.'; + + readonly annotations = { + title: 'Calculate Distance', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: false // Offline calculation, no external APIs + }; + + constructor() { + super({ + inputSchema: DistanceInputSchema, + outputSchema: DistanceOutputSchema + }); + } + + /** + * Execute the distance calculation + * @param rawInput - Input containing from/to coordinates and units + * @returns CallToolResult with calculated distance + */ + async run(rawInput: unknown): Promise { + // Create tracing context for this tool + const toolContext = createLocalToolExecutionContext(this.name, 0); + return await context.with( + trace.setSpan(context.active(), toolContext.span), + async () => { + try { + // Validate input + const input = DistanceInputSchema.parse(rawInput); + const { from, to, units } = input; + + // Calculate distance using Turf.js + // Turf expects [longitude, latitude] + const distance = turfDistance( + [from.longitude, from.latitude], + [to.longitude, to.latitude], + { units } + ); + + const result: DistanceOutput = { + distance: Math.round(distance * 1000) / 1000, // Round to 3 decimal places + units, + from, + to + }; + + // Validate output with graceful fallback + const validatedResult = this.validateOutput(result) as DistanceOutput; + + // Create readable text output + const text = + `Distance: ${validatedResult.distance} ${validatedResult.units}\n` + + `From: [${validatedResult.from.longitude}, ${validatedResult.from.latitude}]\n` + + `To: [${validatedResult.to.longitude}, ${validatedResult.to.latitude}]`; + + toolContext.span.setStatus({ code: SpanStatusCode.OK }); + toolContext.span.end(); + + return { + content: [{ type: 'text' as const, text }], + structuredContent: validatedResult, + isError: false + }; + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : String(error); + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); + toolContext.span.end(); + this.log( + 'error', + `${this.name}: Error during execution: ${errorMessage}` + ); + return { + content: [ + { + type: 'text' as const, + text: `DistanceTool: Error during execution: ${errorMessage}` + } + ], + isError: true + }; + } + } + ); + } +} diff --git a/src/tools/toolRegistry.ts b/src/tools/toolRegistry.ts index 3bb828a..ece161e 100644 --- a/src/tools/toolRegistry.ts +++ b/src/tools/toolRegistry.ts @@ -2,6 +2,7 @@ // Licensed under the MIT License. // INSERT NEW TOOL IMPORT HERE +import { DistanceTool } from './distance-tool/DistanceTool.js'; import { CategoryListTool } from './category-list-tool/CategoryListTool.js'; import { CategorySearchTool } from './category-search-tool/CategorySearchTool.js'; import { DirectionsTool } from './directions-tool/DirectionsTool.js'; @@ -19,6 +20,7 @@ import { httpRequest } from '../utils/httpPipeline.js'; // Central registry of all tools export const ALL_TOOLS = [ // INSERT NEW TOOL INSTANCE HERE + new DistanceTool(), new VersionTool(), new ResourceReaderTool(), new CategoryListTool({ httpRequest }), diff --git a/src/utils/versionUtils-cjs.cjs b/src/utils/versionUtils-cjs.cjs new file mode 100644 index 0000000..7db3f24 --- /dev/null +++ b/src/utils/versionUtils-cjs.cjs @@ -0,0 +1,48 @@ +"use strict"; +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getVersionInfo = getVersionInfo; +const node_fs_1 = require("node:fs"); +const node_path_1 = __importDefault(require("node:path")); +function getVersionInfo() { + const name = 'Mapbox MCP server'; + try { + const dirname = __dirname; + // Try to read from version.json first (for build artifacts) + const versionJsonPath = node_path_1.default.resolve(dirname, '..', 'version.json'); + try { + const versionData = (0, node_fs_1.readFileSync)(versionJsonPath, 'utf-8'); + const info = JSON.parse(versionData); + info['name'] = name; + return info; + } + catch { + // Fall back to package.json + const packageJsonPath = node_path_1.default.resolve(dirname, '..', '..', '..', 'package.json'); + const packageData = (0, node_fs_1.readFileSync)(packageJsonPath, 'utf-8'); + const packageInfo = JSON.parse(packageData); + return { + name: name, + version: packageInfo.version || '0.0.0', + sha: 'unknown', + tag: 'unknown', + branch: 'unknown' + }; + } + } + catch (error) { + console.warn(`Failed to read version info: ${error}`); + return { + name: name, + version: '0.0.0', + sha: 'unknown', + tag: 'unknown', + branch: 'unknown' + }; + } +} +//# sourceMappingURL=versionUtils-cjs.cjs.map \ No newline at end of file diff --git a/src/utils/versionUtils-cjs.cjs.map b/src/utils/versionUtils-cjs.cjs.map new file mode 100644 index 0000000..3a15e8d --- /dev/null +++ b/src/utils/versionUtils-cjs.cjs.map @@ -0,0 +1 @@ +{"version":3,"file":"versionUtils-cjs.cjs","sourceRoot":"","sources":["versionUtils-cjs.cts"],"names":[],"mappings":";AAAA,6BAA6B;AAC7B,kCAAkC;;;;;AAalC,wCA0CC;AArDD,qCAAuC;AACvC,0DAA6B;AAU7B,SAAgB,cAAc;IAC5B,MAAM,IAAI,GAAG,mBAAmB,CAAC;IACjC,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,SAAS,CAAC;QAE1B,4DAA4D;QAC5D,MAAM,eAAe,GAAG,mBAAI,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;QACpE,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,IAAA,sBAAY,EAAC,eAAe,EAAE,OAAO,CAAC,CAAC;YAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAgB,CAAC;YACpD,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;YACpB,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,MAAM,CAAC;YACP,4BAA4B;YAC5B,MAAM,eAAe,GAAG,mBAAI,CAAC,OAAO,CAClC,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,cAAc,CACf,CAAC;YACF,MAAM,WAAW,GAAG,IAAA,sBAAY,EAAC,eAAe,EAAE,OAAO,CAAC,CAAC;YAC3D,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAE5C,OAAO;gBACL,IAAI,EAAE,IAAI;gBACV,OAAO,EAAE,WAAW,CAAC,OAAO,IAAI,OAAO;gBACvC,GAAG,EAAE,SAAS;gBACd,GAAG,EAAE,SAAS;gBACd,MAAM,EAAE,SAAS;aAClB,CAAC;QACJ,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,IAAI,CAAC,gCAAgC,KAAK,EAAE,CAAC,CAAC;QACtD,OAAO;YACL,IAAI,EAAE,IAAI;YACV,OAAO,EAAE,OAAO;YAChB,GAAG,EAAE,SAAS;YACd,GAAG,EAAE,SAAS;YACd,MAAM,EAAE,SAAS;SAClB,CAAC;IACJ,CAAC;AACH,CAAC"} \ No newline at end of file diff --git a/src/utils/versionUtils-cjs.d.cts b/src/utils/versionUtils-cjs.d.cts new file mode 100644 index 0000000..3f06875 --- /dev/null +++ b/src/utils/versionUtils-cjs.d.cts @@ -0,0 +1,9 @@ +export interface VersionInfo { + name: string; + version: string; + sha: string; + tag: string; + branch: string; +} +export declare function getVersionInfo(): VersionInfo; +//# sourceMappingURL=versionUtils-cjs.d.cts.map \ No newline at end of file diff --git a/src/utils/versionUtils-cjs.d.cts.map b/src/utils/versionUtils-cjs.d.cts.map new file mode 100644 index 0000000..7e99013 --- /dev/null +++ b/src/utils/versionUtils-cjs.d.cts.map @@ -0,0 +1 @@ +{"version":3,"file":"versionUtils-cjs.d.cts","sourceRoot":"","sources":["versionUtils-cjs.cts"],"names":[],"mappings":"AAMA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,cAAc,IAAI,WAAW,CA0C5C"} \ No newline at end of file diff --git a/test/tools/annotations.test.ts b/test/tools/annotations.test.ts index f2c1152..e7a9e41 100644 --- a/test/tools/annotations.test.ts +++ b/test/tools/annotations.test.ts @@ -62,18 +62,23 @@ describe('Tool Annotations', () => { const tools = getAllTools(); // Most Mapbox API tools interact with external services (open world) - const apiTools = tools.filter((tool) => tool.name !== 'version_tool'); + // Exclude offline/local tools that don't make external API calls + const offlineTools = ['version_tool', 'distance_tool']; + const apiTools = tools.filter((tool) => !offlineTools.includes(tool.name)); apiTools.forEach((tool) => { expect(tool.annotations.openWorldHint).toBe(true); }); }); - it('should have closed world hint for version tool', () => { + it('should have closed world hint for offline tools', () => { const tools = getAllTools(); - const versionTool = tools.find((tool) => tool.name === 'version_tool'); + const offlineTools = tools.filter((tool) => + ['version_tool', 'distance_tool'].includes(tool.name) + ); - expect(versionTool).toBeDefined(); - expect(versionTool!.annotations.openWorldHint).toBe(false); + offlineTools.forEach((tool) => { + expect(tool.annotations.openWorldHint).toBe(false); + }); }); }); diff --git a/test/tools/distance-tool/DistanceTool.test.ts b/test/tools/distance-tool/DistanceTool.test.ts new file mode 100644 index 0000000..22f7e94 --- /dev/null +++ b/test/tools/distance-tool/DistanceTool.test.ts @@ -0,0 +1,101 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { describe, it, expect } from 'vitest'; +import { DistanceTool } from '../../../src/tools/distance-tool/DistanceTool.js'; + +describe('DistanceTool', () => { + const tool = new DistanceTool(); + + it('should calculate distance between two points in kilometers', async () => { + const result = await tool.run({ + from: { longitude: -122.4194, latitude: 37.7749 }, // San Francisco + to: { longitude: -118.2437, latitude: 34.0522 }, // Los Angeles + units: 'kilometers' + }); + + expect(result.structuredContent?.distance).toBeCloseTo(559, 0); + expect(result.structuredContent?.units).toBe('kilometers'); + expect(result.structuredContent?.from).toEqual({ + longitude: -122.4194, + latitude: 37.7749 + }); + expect(result.structuredContent?.to).toEqual({ + longitude: -118.2437, + latitude: 34.0522 + }); + }); + + it('should calculate distance in miles', async () => { + const result = await tool.run({ + from: { longitude: -122.4194, latitude: 37.7749 }, // San Francisco + to: { longitude: -118.2437, latitude: 34.0522 }, // Los Angeles + units: 'miles' + }); + + expect(result.structuredContent?.distance).toBeCloseTo(347, 0); + expect(result.structuredContent?.units).toBe('miles'); + }); + + it('should calculate distance in meters', async () => { + const result = await tool.run({ + from: { longitude: -122.4194, latitude: 37.7749 }, // San Francisco + to: { longitude: -118.2437, latitude: 34.0522 }, // Los Angeles + units: 'meters' + }); + + expect(result.structuredContent?.distance).toBeGreaterThan(559000); + expect(result.structuredContent?.units).toBe('meters'); + }); + + it('should default to kilometers when units not specified', async () => { + const result = await tool.run({ + from: { longitude: -122.4194, latitude: 37.7749 }, + to: { longitude: -118.2437, latitude: 34.0522 } + }); + + expect(result.structuredContent?.units).toBe('kilometers'); + }); + + it('should calculate short distances accurately', async () => { + const result = await tool.run({ + from: { longitude: 0, latitude: 0 }, + to: { longitude: 0, latitude: 0.01 }, // ~1.11 km + units: 'meters' + }); + + expect(result.structuredContent?.distance).toBeCloseTo(1112, 0); + }); + + it('should handle cross-hemisphere distances', async () => { + const result = await tool.run({ + from: { longitude: -73.935242, latitude: 40.73061 }, // New York + to: { longitude: 139.691706, latitude: 35.689487 }, // Tokyo + units: 'kilometers' + }); + + expect(result.structuredContent?.distance).toBeCloseTo(10850, 0); + }); + + it('should calculate distance for same point as zero', async () => { + const result = await tool.run({ + from: { longitude: 0, latitude: 0 }, + to: { longitude: 0, latitude: 0 }, + units: 'kilometers' + }); + + expect(result.structuredContent?.distance).toBe(0); + }); + + it('should round distance to 3 decimal places', async () => { + const result = await tool.run({ + from: { longitude: 0, latitude: 0 }, + to: { longitude: 0.001, latitude: 0.001 }, + units: 'kilometers' + }); + + const distance = result.structuredContent?.distance as number; + const decimalPlaces = (distance.toString().split('.')[1] || '').length; + expect(decimalPlaces).toBeLessThanOrEqual(3); + }); +}); diff --git a/tsconfig.src.tsbuildinfo b/tsconfig.src.tsbuildinfo new file mode 100644 index 0000000..85e41e8 --- /dev/null +++ b/tsconfig.src.tsbuildinfo @@ -0,0 +1 @@ +{"fileNames":["./node_modules/typescript/lib/lib.es5.d.ts","./node_modules/typescript/lib/lib.es2015.d.ts","./node_modules/typescript/lib/lib.es2016.d.ts","./node_modules/typescript/lib/lib.es2017.d.ts","./node_modules/typescript/lib/lib.es2018.d.ts","./node_modules/typescript/lib/lib.es2019.d.ts","./node_modules/typescript/lib/lib.es2020.d.ts","./node_modules/typescript/lib/lib.es2021.d.ts","./node_modules/typescript/lib/lib.es2022.d.ts","./node_modules/typescript/lib/lib.es2023.d.ts","./node_modules/typescript/lib/lib.es2024.d.ts","./node_modules/typescript/lib/lib.esnext.d.ts","./node_modules/typescript/lib/lib.es2015.core.d.ts","./node_modules/typescript/lib/lib.es2015.collection.d.ts","./node_modules/typescript/lib/lib.es2015.generator.d.ts","./node_modules/typescript/lib/lib.es2015.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.promise.d.ts","./node_modules/typescript/lib/lib.es2015.proxy.d.ts","./node_modules/typescript/lib/lib.es2015.reflect.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2016.array.include.d.ts","./node_modules/typescript/lib/lib.es2016.intl.d.ts","./node_modules/typescript/lib/lib.es2017.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2017.date.d.ts","./node_modules/typescript/lib/lib.es2017.object.d.ts","./node_modules/typescript/lib/lib.es2017.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2017.string.d.ts","./node_modules/typescript/lib/lib.es2017.intl.d.ts","./node_modules/typescript/lib/lib.es2017.typedarrays.d.ts","./node_modules/typescript/lib/lib.es2018.asyncgenerator.d.ts","./node_modules/typescript/lib/lib.es2018.asynciterable.d.ts","./node_modules/typescript/lib/lib.es2018.intl.d.ts","./node_modules/typescript/lib/lib.es2018.promise.d.ts","./node_modules/typescript/lib/lib.es2018.regexp.d.ts","./node_modules/typescript/lib/lib.es2019.array.d.ts","./node_modules/typescript/lib/lib.es2019.object.d.ts","./node_modules/typescript/lib/lib.es2019.string.d.ts","./node_modules/typescript/lib/lib.es2019.symbol.d.ts","./node_modules/typescript/lib/lib.es2019.intl.d.ts","./node_modules/typescript/lib/lib.es2020.bigint.d.ts","./node_modules/typescript/lib/lib.es2020.date.d.ts","./node_modules/typescript/lib/lib.es2020.promise.d.ts","./node_modules/typescript/lib/lib.es2020.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2020.string.d.ts","./node_modules/typescript/lib/lib.es2020.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2020.intl.d.ts","./node_modules/typescript/lib/lib.es2020.number.d.ts","./node_modules/typescript/lib/lib.es2021.promise.d.ts","./node_modules/typescript/lib/lib.es2021.string.d.ts","./node_modules/typescript/lib/lib.es2021.weakref.d.ts","./node_modules/typescript/lib/lib.es2021.intl.d.ts","./node_modules/typescript/lib/lib.es2022.array.d.ts","./node_modules/typescript/lib/lib.es2022.error.d.ts","./node_modules/typescript/lib/lib.es2022.intl.d.ts","./node_modules/typescript/lib/lib.es2022.object.d.ts","./node_modules/typescript/lib/lib.es2022.string.d.ts","./node_modules/typescript/lib/lib.es2022.regexp.d.ts","./node_modules/typescript/lib/lib.es2023.array.d.ts","./node_modules/typescript/lib/lib.es2023.collection.d.ts","./node_modules/typescript/lib/lib.es2023.intl.d.ts","./node_modules/typescript/lib/lib.es2024.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2024.collection.d.ts","./node_modules/typescript/lib/lib.es2024.object.d.ts","./node_modules/typescript/lib/lib.es2024.promise.d.ts","./node_modules/typescript/lib/lib.es2024.regexp.d.ts","./node_modules/typescript/lib/lib.es2024.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2024.string.d.ts","./node_modules/typescript/lib/lib.esnext.array.d.ts","./node_modules/typescript/lib/lib.esnext.collection.d.ts","./node_modules/typescript/lib/lib.esnext.intl.d.ts","./node_modules/typescript/lib/lib.esnext.disposable.d.ts","./node_modules/typescript/lib/lib.esnext.promise.d.ts","./node_modules/typescript/lib/lib.esnext.decorators.d.ts","./node_modules/typescript/lib/lib.esnext.iterator.d.ts","./node_modules/typescript/lib/lib.esnext.float16.d.ts","./node_modules/typescript/lib/lib.decorators.d.ts","./node_modules/typescript/lib/lib.decorators.legacy.d.ts","./node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.d.ts","./node_modules/@opentelemetry/api/build/src/baggage/types.d.ts","./node_modules/@opentelemetry/api/build/src/baggage/utils.d.ts","./node_modules/@opentelemetry/api/build/src/common/exception.d.ts","./node_modules/@opentelemetry/api/build/src/common/time.d.ts","./node_modules/@opentelemetry/api/build/src/common/attributes.d.ts","./node_modules/@opentelemetry/api/build/src/context/types.d.ts","./node_modules/@opentelemetry/api/build/src/context/context.d.ts","./node_modules/@opentelemetry/api/build/src/api/context.d.ts","./node_modules/@opentelemetry/api/build/src/diag/types.d.ts","./node_modules/@opentelemetry/api/build/src/diag/consolelogger.d.ts","./node_modules/@opentelemetry/api/build/src/api/diag.d.ts","./node_modules/@opentelemetry/api/build/src/metrics/observableresult.d.ts","./node_modules/@opentelemetry/api/build/src/metrics/metric.d.ts","./node_modules/@opentelemetry/api/build/src/metrics/meter.d.ts","./node_modules/@opentelemetry/api/build/src/metrics/noopmeter.d.ts","./node_modules/@opentelemetry/api/build/src/metrics/meterprovider.d.ts","./node_modules/@opentelemetry/api/build/src/api/metrics.d.ts","./node_modules/@opentelemetry/api/build/src/propagation/textmappropagator.d.ts","./node_modules/@opentelemetry/api/build/src/baggage/context-helpers.d.ts","./node_modules/@opentelemetry/api/build/src/api/propagation.d.ts","./node_modules/@opentelemetry/api/build/src/trace/attributes.d.ts","./node_modules/@opentelemetry/api/build/src/trace/trace_state.d.ts","./node_modules/@opentelemetry/api/build/src/trace/span_context.d.ts","./node_modules/@opentelemetry/api/build/src/trace/link.d.ts","./node_modules/@opentelemetry/api/build/src/trace/status.d.ts","./node_modules/@opentelemetry/api/build/src/trace/span.d.ts","./node_modules/@opentelemetry/api/build/src/trace/span_kind.d.ts","./node_modules/@opentelemetry/api/build/src/trace/spanoptions.d.ts","./node_modules/@opentelemetry/api/build/src/trace/tracer.d.ts","./node_modules/@opentelemetry/api/build/src/trace/tracer_options.d.ts","./node_modules/@opentelemetry/api/build/src/trace/proxytracer.d.ts","./node_modules/@opentelemetry/api/build/src/trace/tracer_provider.d.ts","./node_modules/@opentelemetry/api/build/src/trace/proxytracerprovider.d.ts","./node_modules/@opentelemetry/api/build/src/trace/samplingresult.d.ts","./node_modules/@opentelemetry/api/build/src/trace/sampler.d.ts","./node_modules/@opentelemetry/api/build/src/trace/trace_flags.d.ts","./node_modules/@opentelemetry/api/build/src/trace/internal/utils.d.ts","./node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.d.ts","./node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.d.ts","./node_modules/@opentelemetry/api/build/src/trace/context-utils.d.ts","./node_modules/@opentelemetry/api/build/src/api/trace.d.ts","./node_modules/@opentelemetry/api/build/src/context-api.d.ts","./node_modules/@opentelemetry/api/build/src/diag-api.d.ts","./node_modules/@opentelemetry/api/build/src/metrics-api.d.ts","./node_modules/@opentelemetry/api/build/src/propagation-api.d.ts","./node_modules/@opentelemetry/api/build/src/trace-api.d.ts","./node_modules/@opentelemetry/api/build/src/index.d.ts","./node_modules/zod/dist/types/v3/helpers/typealiases.d.ts","./node_modules/zod/dist/types/v3/helpers/util.d.ts","./node_modules/zod/dist/types/v3/zoderror.d.ts","./node_modules/zod/dist/types/v3/locales/en.d.ts","./node_modules/zod/dist/types/v3/errors.d.ts","./node_modules/zod/dist/types/v3/helpers/parseutil.d.ts","./node_modules/zod/dist/types/v3/helpers/enumutil.d.ts","./node_modules/zod/dist/types/v3/helpers/errorutil.d.ts","./node_modules/zod/dist/types/v3/helpers/partialutil.d.ts","./node_modules/zod/dist/types/v3/standard-schema.d.ts","./node_modules/zod/dist/types/v3/types.d.ts","./node_modules/zod/dist/types/v3/external.d.ts","./node_modules/zod/dist/types/v3/index.d.ts","./node_modules/zod/dist/types/index.d.ts","./node_modules/zod/dist/types/v4/core/standard-schema.d.ts","./node_modules/zod/dist/types/v4/core/util.d.ts","./node_modules/zod/dist/types/v4/core/versions.d.ts","./node_modules/zod/dist/types/v4/core/schemas.d.ts","./node_modules/zod/dist/types/v4/core/checks.d.ts","./node_modules/zod/dist/types/v4/core/errors.d.ts","./node_modules/zod/dist/types/v4/core/core.d.ts","./node_modules/zod/dist/types/v4/core/parse.d.ts","./node_modules/zod/dist/types/v4/core/regexes.d.ts","./node_modules/zod/dist/types/v4/locales/ar.d.ts","./node_modules/zod/dist/types/v4/locales/az.d.ts","./node_modules/zod/dist/types/v4/locales/be.d.ts","./node_modules/zod/dist/types/v4/locales/ca.d.ts","./node_modules/zod/dist/types/v4/locales/cs.d.ts","./node_modules/zod/dist/types/v4/locales/de.d.ts","./node_modules/zod/dist/types/v4/locales/en.d.ts","./node_modules/zod/dist/types/v4/locales/es.d.ts","./node_modules/zod/dist/types/v4/locales/fa.d.ts","./node_modules/zod/dist/types/v4/locales/fi.d.ts","./node_modules/zod/dist/types/v4/locales/fr.d.ts","./node_modules/zod/dist/types/v4/locales/fr-ca.d.ts","./node_modules/zod/dist/types/v4/locales/he.d.ts","./node_modules/zod/dist/types/v4/locales/hu.d.ts","./node_modules/zod/dist/types/v4/locales/id.d.ts","./node_modules/zod/dist/types/v4/locales/it.d.ts","./node_modules/zod/dist/types/v4/locales/ja.d.ts","./node_modules/zod/dist/types/v4/locales/kh.d.ts","./node_modules/zod/dist/types/v4/locales/ko.d.ts","./node_modules/zod/dist/types/v4/locales/mk.d.ts","./node_modules/zod/dist/types/v4/locales/ms.d.ts","./node_modules/zod/dist/types/v4/locales/nl.d.ts","./node_modules/zod/dist/types/v4/locales/no.d.ts","./node_modules/zod/dist/types/v4/locales/ota.d.ts","./node_modules/zod/dist/types/v4/locales/pl.d.ts","./node_modules/zod/dist/types/v4/locales/pt.d.ts","./node_modules/zod/dist/types/v4/locales/ru.d.ts","./node_modules/zod/dist/types/v4/locales/sl.d.ts","./node_modules/zod/dist/types/v4/locales/sv.d.ts","./node_modules/zod/dist/types/v4/locales/ta.d.ts","./node_modules/zod/dist/types/v4/locales/th.d.ts","./node_modules/zod/dist/types/v4/locales/tr.d.ts","./node_modules/zod/dist/types/v4/locales/ua.d.ts","./node_modules/zod/dist/types/v4/locales/ur.d.ts","./node_modules/zod/dist/types/v4/locales/vi.d.ts","./node_modules/zod/dist/types/v4/locales/zh-cn.d.ts","./node_modules/zod/dist/types/v4/locales/zh-tw.d.ts","./node_modules/zod/dist/types/v4/locales/index.d.ts","./node_modules/zod/dist/types/v4/core/registries.d.ts","./node_modules/zod/dist/types/v4/core/doc.d.ts","./node_modules/zod/dist/types/v4/core/function.d.ts","./node_modules/zod/dist/types/v4/core/api.d.ts","./node_modules/zod/dist/types/v4/core/json-schema.d.ts","./node_modules/zod/dist/types/v4/core/to-json-schema.d.ts","./node_modules/zod/dist/types/v4/core/index.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.d.ts","./node_modules/zod/dist/types/v4/classic/errors.d.ts","./node_modules/zod/dist/types/v4/classic/parse.d.ts","./node_modules/zod/dist/types/v4/classic/schemas.d.ts","./node_modules/zod/dist/types/v4/classic/checks.d.ts","./node_modules/zod/dist/types/v4/classic/compat.d.ts","./node_modules/zod/dist/types/v4/classic/iso.d.ts","./node_modules/zod/dist/types/v4/classic/coerce.d.ts","./node_modules/zod/dist/types/v4/classic/external.d.ts","./node_modules/zod/dist/types/v4/classic/index.d.ts","./node_modules/zod/dist/types/v4/index.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/types.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/types.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/types.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/shared/responsemessage.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.d.ts","./node_modules/json-schema-typed/draft_2020_12.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/validation/types.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/shared/uritemplate.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.d.ts","./node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/stores/in-memory.d.ts","./src/tools/basetool.ts","./src/utils/types.ts","./node_modules/@opentelemetry/core/build/src/baggage/propagation/w3cbaggagepropagator.d.ts","./node_modules/@opentelemetry/core/build/src/common/anchored-clock.d.ts","./node_modules/@opentelemetry/core/build/src/common/attributes.d.ts","./node_modules/@opentelemetry/core/build/src/common/types.d.ts","./node_modules/@opentelemetry/core/build/src/common/global-error-handler.d.ts","./node_modules/@opentelemetry/core/build/src/common/logging-error-handler.d.ts","./node_modules/@opentelemetry/core/build/src/common/time.d.ts","./node_modules/@opentelemetry/core/build/src/common/hex-to-binary.d.ts","./node_modules/@opentelemetry/core/build/src/exportresult.d.ts","./node_modules/@opentelemetry/core/build/src/baggage/utils.d.ts","./node_modules/@opentelemetry/core/build/src/utils/environment.d.ts","./node_modules/@opentelemetry/core/build/src/platform/node/environment.d.ts","./node_modules/@opentelemetry/core/build/src/platform/node/globalthis.d.ts","./node_modules/@opentelemetry/core/build/src/platform/node/hex-to-base64.d.ts","./node_modules/@opentelemetry/core/build/src/trace/idgenerator.d.ts","./node_modules/@opentelemetry/core/build/src/platform/node/randomidgenerator.d.ts","./node_modules/@types/node/compatibility/disposable.d.ts","./node_modules/@types/node/compatibility/indexable.d.ts","./node_modules/@types/node/compatibility/iterators.d.ts","./node_modules/@types/node/compatibility/index.d.ts","./node_modules/@types/node/globals.typedarray.d.ts","./node_modules/@types/node/buffer.buffer.d.ts","./node_modules/buffer/index.d.ts","./node_modules/undici-types/header.d.ts","./node_modules/undici-types/readable.d.ts","./node_modules/undici-types/file.d.ts","./node_modules/undici-types/fetch.d.ts","./node_modules/undici-types/formdata.d.ts","./node_modules/undici-types/connector.d.ts","./node_modules/undici-types/client.d.ts","./node_modules/undici-types/errors.d.ts","./node_modules/undici-types/dispatcher.d.ts","./node_modules/undici-types/global-dispatcher.d.ts","./node_modules/undici-types/global-origin.d.ts","./node_modules/undici-types/pool-stats.d.ts","./node_modules/undici-types/pool.d.ts","./node_modules/undici-types/handlers.d.ts","./node_modules/undici-types/balanced-pool.d.ts","./node_modules/undici-types/agent.d.ts","./node_modules/undici-types/mock-interceptor.d.ts","./node_modules/undici-types/mock-agent.d.ts","./node_modules/undici-types/mock-client.d.ts","./node_modules/undici-types/mock-pool.d.ts","./node_modules/undici-types/mock-errors.d.ts","./node_modules/undici-types/proxy-agent.d.ts","./node_modules/undici-types/env-http-proxy-agent.d.ts","./node_modules/undici-types/retry-handler.d.ts","./node_modules/undici-types/retry-agent.d.ts","./node_modules/undici-types/api.d.ts","./node_modules/undici-types/interceptors.d.ts","./node_modules/undici-types/util.d.ts","./node_modules/undici-types/cookies.d.ts","./node_modules/undici-types/patch.d.ts","./node_modules/undici-types/websocket.d.ts","./node_modules/undici-types/eventsource.d.ts","./node_modules/undici-types/filereader.d.ts","./node_modules/undici-types/diagnostics-channel.d.ts","./node_modules/undici-types/content-type.d.ts","./node_modules/undici-types/cache.d.ts","./node_modules/undici-types/index.d.ts","./node_modules/@types/node/globals.d.ts","./node_modules/@types/node/assert.d.ts","./node_modules/@types/node/assert/strict.d.ts","./node_modules/@types/node/async_hooks.d.ts","./node_modules/@types/node/buffer.d.ts","./node_modules/@types/node/child_process.d.ts","./node_modules/@types/node/cluster.d.ts","./node_modules/@types/node/console.d.ts","./node_modules/@types/node/constants.d.ts","./node_modules/@types/node/crypto.d.ts","./node_modules/@types/node/dgram.d.ts","./node_modules/@types/node/diagnostics_channel.d.ts","./node_modules/@types/node/dns.d.ts","./node_modules/@types/node/dns/promises.d.ts","./node_modules/@types/node/domain.d.ts","./node_modules/@types/node/dom-events.d.ts","./node_modules/@types/node/events.d.ts","./node_modules/@types/node/fs.d.ts","./node_modules/@types/node/fs/promises.d.ts","./node_modules/@types/node/http.d.ts","./node_modules/@types/node/http2.d.ts","./node_modules/@types/node/https.d.ts","./node_modules/@types/node/inspector.d.ts","./node_modules/@types/node/module.d.ts","./node_modules/@types/node/net.d.ts","./node_modules/@types/node/os.d.ts","./node_modules/@types/node/path.d.ts","./node_modules/@types/node/perf_hooks.d.ts","./node_modules/@types/node/process.d.ts","./node_modules/@types/node/punycode.d.ts","./node_modules/@types/node/querystring.d.ts","./node_modules/@types/node/readline.d.ts","./node_modules/@types/node/readline/promises.d.ts","./node_modules/@types/node/repl.d.ts","./node_modules/@types/node/sea.d.ts","./node_modules/@types/node/sqlite.d.ts","./node_modules/@types/node/stream.d.ts","./node_modules/@types/node/stream/promises.d.ts","./node_modules/@types/node/stream/consumers.d.ts","./node_modules/@types/node/stream/web.d.ts","./node_modules/@types/node/string_decoder.d.ts","./node_modules/@types/node/test.d.ts","./node_modules/@types/node/timers.d.ts","./node_modules/@types/node/timers/promises.d.ts","./node_modules/@types/node/tls.d.ts","./node_modules/@types/node/trace_events.d.ts","./node_modules/@types/node/tty.d.ts","./node_modules/@types/node/url.d.ts","./node_modules/@types/node/util.d.ts","./node_modules/@types/node/v8.d.ts","./node_modules/@types/node/vm.d.ts","./node_modules/@types/node/wasi.d.ts","./node_modules/@types/node/worker_threads.d.ts","./node_modules/@types/node/zlib.d.ts","./node_modules/@types/node/index.d.ts","./node_modules/@opentelemetry/core/build/src/platform/node/performance.d.ts","./node_modules/@opentelemetry/core/build/src/platform/node/sdk-info.d.ts","./node_modules/@opentelemetry/core/build/src/platform/node/timer-util.d.ts","./node_modules/@opentelemetry/core/build/src/platform/node/index.d.ts","./node_modules/@opentelemetry/core/build/src/platform/index.d.ts","./node_modules/@opentelemetry/core/build/src/propagation/composite.d.ts","./node_modules/@opentelemetry/core/build/src/trace/w3ctracecontextpropagator.d.ts","./node_modules/@opentelemetry/core/build/src/trace/rpc-metadata.d.ts","./node_modules/@opentelemetry/core/build/src/trace/sampler/alwaysoffsampler.d.ts","./node_modules/@opentelemetry/core/build/src/trace/sampler/alwaysonsampler.d.ts","./node_modules/@opentelemetry/core/build/src/trace/sampler/parentbasedsampler.d.ts","./node_modules/@opentelemetry/core/build/src/trace/sampler/traceidratiobasedsampler.d.ts","./node_modules/@opentelemetry/core/build/src/trace/suppress-tracing.d.ts","./node_modules/@opentelemetry/core/build/src/trace/tracestate.d.ts","./node_modules/@opentelemetry/core/build/src/utils/merge.d.ts","./node_modules/@opentelemetry/core/build/src/utils/sampling.d.ts","./node_modules/@opentelemetry/core/build/src/utils/timeout.d.ts","./node_modules/@opentelemetry/core/build/src/utils/url.d.ts","./node_modules/@opentelemetry/core/build/src/utils/wrap.d.ts","./node_modules/@opentelemetry/core/build/src/utils/callback.d.ts","./node_modules/@opentelemetry/core/build/src/version.d.ts","./node_modules/@opentelemetry/core/build/src/internal/exporter.d.ts","./node_modules/@opentelemetry/core/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/config.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/iresource.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/types.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/resource.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/platform/node/default-service-name.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/platform/node/index.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/platform/index.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/hostdetector.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/hostdetectorsync.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/osdetector.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/osdetectorsync.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/processdetector.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/processdetectorsync.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/serviceinstanceiddetectorsync.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/index.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/platform/index.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/browserdetector.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/envdetector.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/browserdetectorsync.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/envdetectorsync.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detectors/index.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/detect-resources.d.ts","./node_modules/@opentelemetry/sdk-logs/node_modules/@opentelemetry/resources/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/types.d.ts","./node_modules/@opentelemetry/api-logs/build/src/types/anyvalue.d.ts","./node_modules/@opentelemetry/api-logs/build/src/types/logrecord.d.ts","./node_modules/@opentelemetry/api-logs/build/src/types/logger.d.ts","./node_modules/@opentelemetry/api-logs/build/src/types/loggeroptions.d.ts","./node_modules/@opentelemetry/api-logs/build/src/types/loggerprovider.d.ts","./node_modules/@opentelemetry/api-logs/build/src/nooplogger.d.ts","./node_modules/@opentelemetry/api-logs/build/src/nooploggerprovider.d.ts","./node_modules/@opentelemetry/api-logs/build/src/proxylogger.d.ts","./node_modules/@opentelemetry/api-logs/build/src/proxyloggerprovider.d.ts","./node_modules/@opentelemetry/api-logs/build/src/api/logs.d.ts","./node_modules/@opentelemetry/api-logs/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/export/readablelogrecord.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/internal/loggerprovidersharedstate.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/logrecord.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/logrecordprocessor.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/loggerprovider.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/export/nooplogrecordprocessor.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/export/logrecordexporter.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/export/consolelogrecordexporter.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/export/simplelogrecordprocessor.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/export/inmemorylogrecordexporter.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/export/batchlogrecordprocessorbase.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/platform/node/export/batchlogrecordprocessor.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/platform/node/index.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/platform/index.d.ts","./node_modules/@opentelemetry/sdk-logs/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-metrics/node_modules/@opentelemetry/resources/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/view/attributesprocessor.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/view/predicate.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/view/instrumentselector.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/view/meterselector.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/export/aggregationtemporality.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/utils.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/types.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/drop.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/histogram.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/buckets.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/mapping/types.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponentialhistogram.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/lastvalue.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/sum.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/index.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/view/aggregation.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/view/view.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/instrumentdescriptor.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/export/metricdata.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/export/aggregationselector.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/export/metricexporter.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/export/metricproducer.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/types.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/export/cardinalityselector.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/export/metricreader.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/export/periodicexportingmetricreader.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/export/inmemorymetricexporter.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/export/consolemetricexporter.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/meterprovider.d.ts","./node_modules/@opentelemetry/sdk-metrics/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/resources/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/idgenerator.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/sampler.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/timedevent.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/export/readablespan.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/span.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/spanprocessor.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/types.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/export/spanexporter.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/basictracerprovider.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/tracer.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/export/batchspanprocessorbase.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/platform/node/export/batchspanprocessor.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/platform/node/randomidgenerator.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/platform/node/index.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/platform/index.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/export/consolespanexporter.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/export/inmemoryspanexporter.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/export/simplespanprocessor.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/export/noopspanprocessor.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/sampler/alwaysoffsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/sampler/alwaysonsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/sampler/parentbasedsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/sampler/traceidratiobasedsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-node/node_modules/@opentelemetry/sdk-trace-base/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-trace-node/build/src/config.d.ts","./node_modules/@opentelemetry/sdk-trace-node/build/src/nodetracerprovider.d.ts","./node_modules/@opentelemetry/sdk-trace-node/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-node/node_modules/@opentelemetry/resources/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-node/node_modules/@opentelemetry/sdk-trace-base/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/types_internal.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/autoloader.d.ts","./node_modules/@types/shimmer/index.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/platform/node/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/platform/node/normalize.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/platform/node/index.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/platform/index.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/instrumentationnodemoduledefinition.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/instrumentationnodemodulefile.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/utils.d.ts","./node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-node/build/src/types.d.ts","./node_modules/@opentelemetry/sdk-node/build/src/sdk.d.ts","./node_modules/@opentelemetry/sdk-node/build/src/index.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/types/anyvalue.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/types/logrecord.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/types/logger.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/types/loggeroptions.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/types/loggerprovider.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/nooplogger.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/nooploggerprovider.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/proxylogger.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/proxyloggerprovider.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/api/logs.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/api-logs/build/src/index.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/types.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/types_internal.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/autoloader.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/platform/node/instrumentation.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/platform/node/normalize.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/platform/node/index.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/platform/index.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/instrumentationnodemoduledefinition.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/instrumentationnodemodulefile.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/utils.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-amqplib/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-amqplib/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-amqplib/build/src/amqplib.d.ts","./node_modules/@opentelemetry/instrumentation-amqplib/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-aws-lambda/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@types/aws-lambda/common/api-gateway.d.ts","./node_modules/@types/aws-lambda/common/cloudfront.d.ts","./node_modules/@types/aws-lambda/handler.d.ts","./node_modules/@types/aws-lambda/trigger/alb.d.ts","./node_modules/@types/aws-lambda/trigger/api-gateway-proxy.d.ts","./node_modules/@types/aws-lambda/trigger/api-gateway-authorizer.d.ts","./node_modules/@types/aws-lambda/trigger/appsync-resolver.d.ts","./node_modules/@types/aws-lambda/trigger/autoscaling.d.ts","./node_modules/@types/aws-lambda/trigger/cloudformation-custom-resource.d.ts","./node_modules/@types/aws-lambda/trigger/cdk-custom-resource.d.ts","./node_modules/@types/aws-lambda/trigger/cloudfront-request.d.ts","./node_modules/@types/aws-lambda/trigger/cloudfront-response.d.ts","./node_modules/@types/aws-lambda/trigger/cloudwatch-alarm.d.ts","./node_modules/@types/aws-lambda/trigger/eventbridge.d.ts","./node_modules/@types/aws-lambda/trigger/cloudwatch-events.d.ts","./node_modules/@types/aws-lambda/trigger/cloudwatch-logs.d.ts","./node_modules/@types/aws-lambda/trigger/codebuild-cloudwatch-state.d.ts","./node_modules/@types/aws-lambda/trigger/codecommit.d.ts","./node_modules/@types/aws-lambda/trigger/codepipeline.d.ts","./node_modules/@types/aws-lambda/trigger/codepipeline-cloudwatch-action.d.ts","./node_modules/@types/aws-lambda/trigger/codepipeline-cloudwatch-pipeline.d.ts","./node_modules/@types/aws-lambda/trigger/codepipeline-cloudwatch-stage.d.ts","./node_modules/@types/aws-lambda/trigger/codepipeline-cloudwatch.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/_common.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/create-auth-challenge.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/custom-email-sender.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/custom-message.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/custom-sms-sender.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/define-auth-challenge.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/post-authentication.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/post-confirmation.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/pre-authentication.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/pre-signup.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/pre-token-generation.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/pre-token-generation-v2.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/user-migration.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/verify-auth-challenge-response.d.ts","./node_modules/@types/aws-lambda/trigger/cognito-user-pool-trigger/index.d.ts","./node_modules/@types/aws-lambda/trigger/connect-contact-flow.d.ts","./node_modules/@types/aws-lambda/trigger/dynamodb-stream.d.ts","./node_modules/@types/aws-lambda/trigger/guard-duty-event-notification.d.ts","./node_modules/@types/aws-lambda/trigger/iot.d.ts","./node_modules/@types/aws-lambda/trigger/iot-authorizer.d.ts","./node_modules/@types/aws-lambda/trigger/kinesis-firehose-transformation.d.ts","./node_modules/@types/aws-lambda/trigger/kinesis-stream.d.ts","./node_modules/@types/aws-lambda/trigger/lambda-function-url.d.ts","./node_modules/@types/aws-lambda/trigger/lex.d.ts","./node_modules/@types/aws-lambda/trigger/lex-v2.d.ts","./node_modules/@types/aws-lambda/trigger/amplify-resolver.d.ts","./node_modules/@types/aws-lambda/trigger/msk.d.ts","./node_modules/@types/aws-lambda/trigger/s3.d.ts","./node_modules/@types/aws-lambda/trigger/s3-batch.d.ts","./node_modules/@types/aws-lambda/trigger/s3-event-notification.d.ts","./node_modules/@types/aws-lambda/trigger/secretsmanager.d.ts","./node_modules/@types/aws-lambda/trigger/self-managed-kafka.d.ts","./node_modules/@types/aws-lambda/trigger/ses.d.ts","./node_modules/@types/aws-lambda/trigger/sns.d.ts","./node_modules/@types/aws-lambda/trigger/sqs.d.ts","./node_modules/@types/aws-lambda/trigger/transfer-family-authorizer.d.ts","./node_modules/@types/aws-lambda/index.d.ts","./node_modules/@opentelemetry/instrumentation-aws-lambda/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-aws-lambda/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-aws-lambda/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-aws-sdk/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-aws-sdk/build/src/aws-sdk.types.d.ts","./node_modules/@opentelemetry/instrumentation-aws-sdk/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-aws-sdk/build/src/aws-sdk.d.ts","./node_modules/@opentelemetry/instrumentation-aws-sdk/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-bunyan/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-bunyan/node_modules/@opentelemetry/api-logs/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-bunyan/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-bunyan/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-bunyan/build/src/opentelemetrybunyanstream.d.ts","./node_modules/@opentelemetry/instrumentation-bunyan/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-cassandra-driver/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-cassandra-driver/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-cassandra-driver/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-cassandra-driver/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-connect/build/src/enums/attributenames.d.ts","./node_modules/@types/connect/index.d.ts","./node_modules/@opentelemetry/instrumentation-connect/build/src/internal-types.d.ts","./node_modules/@opentelemetry/instrumentation-connect/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-connect/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-connect/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-cucumber/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-cucumber/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-cucumber/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-cucumber/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-dataloader/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-dataloader/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-dataloader/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-dataloader/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-dns/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-dns/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-dns/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-dns/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-express/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-express/build/src/enums/expresslayertype.d.ts","./node_modules/@opentelemetry/instrumentation-express/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-express/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-express/build/src/enums/attributenames.d.ts","./node_modules/@opentelemetry/instrumentation-express/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-fastify/build/src/enums/attributenames.d.ts","./node_modules/@opentelemetry/instrumentation-fastify/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-fastify/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-fastify/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-fastify/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-fs/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-fs/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-fs/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-fs/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-generic-pool/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-generic-pool/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-generic-pool/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-graphql/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-graphql/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-graphql/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-graphql/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-grpc/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-grpc/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-grpc/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-grpc/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-hapi/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-hapi/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-hapi/build/src/enums/attributenames.d.ts","./node_modules/@opentelemetry/instrumentation-hapi/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-http/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-http/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-http/build/src/http.d.ts","./node_modules/@opentelemetry/instrumentation-http/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-ioredis/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-ioredis/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-ioredis/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-ioredis/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-kafkajs/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-kafkajs/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-kafkajs/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-kafkajs/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-knex/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-knex/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-knex/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-knex/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-koa/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-koa/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-koa/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-koa/build/src/enums/attributenames.d.ts","./node_modules/@opentelemetry/instrumentation-koa/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-lru-memoizer/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-lru-memoizer/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-lru-memoizer/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-memcached/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@types/memcached/index.d.ts","./node_modules/@opentelemetry/instrumentation-memcached/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-memcached/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-memcached/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-mongodb/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-mongodb/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-mongodb/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-mongodb/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-mongoose/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-mongoose/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-mongoose/build/src/mongoose.d.ts","./node_modules/@opentelemetry/instrumentation-mongoose/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-mysql2/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-mysql2/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-mysql2/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-mysql2/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-mysql/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-mysql/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-mysql/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-mysql/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-nestjs-core/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-nestjs-core/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-nestjs-core/build/src/enums/attributenames.d.ts","./node_modules/@opentelemetry/instrumentation-nestjs-core/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-net/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-net/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-net/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-net/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-pg/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/pg-types/index.d.ts","./node_modules/pg-protocol/dist/messages.d.ts","./node_modules/pg-protocol/dist/serializer.d.ts","./node_modules/pg-protocol/dist/parser.d.ts","./node_modules/pg-protocol/dist/index.d.ts","./node_modules/@types/pg/index.d.ts","./node_modules/@opentelemetry/instrumentation-pg/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-pg/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-pg/build/src/enums/attributenames.d.ts","./node_modules/@opentelemetry/instrumentation-pg/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-pino/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-pino/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-pino/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-pino/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-redis/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-redis/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-redis/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-redis/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-redis-4/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-redis-4/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-redis-4/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-redis-4/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-restify/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-restify/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-restify/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-restify/build/src/enums/attributenames.d.ts","./node_modules/@opentelemetry/instrumentation-restify/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-router/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-router/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-router/build/src/enums/attributenames.d.ts","./node_modules/@opentelemetry/instrumentation-router/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-socket.io/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-socket.io/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-socket.io/build/src/socket.io.d.ts","./node_modules/@opentelemetry/instrumentation-socket.io/build/src/attributenames.d.ts","./node_modules/@opentelemetry/instrumentation-socket.io/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-tedious/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-tedious/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-tedious/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-tedious/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-undici/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-undici/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-undici/build/src/undici.d.ts","./node_modules/@opentelemetry/instrumentation-undici/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-winston/node_modules/@opentelemetry/instrumentation/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-winston/node_modules/@opentelemetry/api-logs/build/src/index.d.ts","./node_modules/@opentelemetry/instrumentation-winston/build/src/types.d.ts","./node_modules/@opentelemetry/instrumentation-winston/build/src/instrumentation.d.ts","./node_modules/@opentelemetry/instrumentation-winston/build/src/index.d.ts","./node_modules/@opentelemetry/resources/build/src/config.d.ts","./node_modules/@opentelemetry/resources/build/src/iresource.d.ts","./node_modules/@opentelemetry/resources/build/src/types.d.ts","./node_modules/@opentelemetry/resources/build/src/resource.d.ts","./node_modules/@opentelemetry/resources/build/src/platform/node/default-service-name.d.ts","./node_modules/@opentelemetry/resources/build/src/platform/node/index.d.ts","./node_modules/@opentelemetry/resources/build/src/platform/index.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/platform/node/hostdetector.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/platform/node/hostdetectorsync.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/platform/node/osdetector.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/platform/node/osdetectorsync.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/platform/node/processdetector.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/platform/node/processdetectorsync.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/platform/node/serviceinstanceiddetectorsync.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/platform/node/index.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/platform/index.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/browserdetector.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/envdetector.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/browserdetectorsync.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/envdetectorsync.d.ts","./node_modules/@opentelemetry/resources/build/src/detectors/index.d.ts","./node_modules/@opentelemetry/resources/build/src/detect-resources.d.ts","./node_modules/@opentelemetry/resources/build/src/index.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/build/src/utils.d.ts","./node_modules/@opentelemetry/auto-instrumentations-node/build/src/index.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/trace/semanticattributes.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/trace/index.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/resource/semanticresourceattributes.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/resource/index.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/stable_attributes.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/stable_metrics.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/stable_events.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/index.d.ts","./node_modules/@opentelemetry/exporter-trace-otlp-http/node_modules/@opentelemetry/sdk-trace-base/build/src/index.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/export-response.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/exporter-transport.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/bounded-queue-export-promise-handler.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/common/types.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/common/index.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/resource/types.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/metrics/types.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/trace/types.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/logs/types.d.ts","./node_modules/@opentelemetry/otlp-transformer/node_modules/@opentelemetry/sdk-trace-base/build/src/index.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/trace/index.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/metrics/index.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/logs/index.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/common/i-serializer.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/protobuf/serializers.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/json/serializers.d.ts","./node_modules/@opentelemetry/otlp-transformer/build/src/index.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/otlp-export-delegate.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/otlpexporterbase.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/types.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/configuration/shared-configuration.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/configuration/legacy-base-configuration.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/configuration/legacy-node-configuration.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/otlp-network-export-delegate.d.ts","./node_modules/@opentelemetry/otlp-exporter-base/build/src/index.d.ts","./node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/platform/node/otlptraceexporter.d.ts","./node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/platform/node/index.d.ts","./node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/platform/index.d.ts","./node_modules/@opentelemetry/exporter-trace-otlp-http/build/src/index.d.ts","./src/utils/versionutils.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/experimental_attributes.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/experimental_metrics.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/experimental_events.d.ts","./node_modules/@opentelemetry/semantic-conventions/build/src/index-incubating.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/baggage/propagation/w3cbaggagepropagator.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/common/anchored-clock.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/common/attributes.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/common/types.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/common/global-error-handler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/common/logging-error-handler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/common/time.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/common/hex-to-binary.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/exportresult.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/baggage/utils.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/utils/environment.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/platform/node/environment.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/platform/node/globalthis.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/platform/node/hex-to-base64.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/trace/idgenerator.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/platform/node/randomidgenerator.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/platform/node/performance.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/platform/node/sdk-info.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/platform/node/timer-util.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/platform/node/index.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/platform/index.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/propagation/composite.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/trace/w3ctracecontextpropagator.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/trace/rpc-metadata.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/trace/sampler/alwaysoffsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/trace/sampler/alwaysonsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/trace/sampler/parentbasedsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/trace/sampler/traceidratiobasedsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/trace/suppress-tracing.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/trace/tracestate.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/utils/merge.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/utils/sampling.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/utils/timeout.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/utils/url.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/utils/wrap.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/utils/callback.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/version.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/internal/exporter.d.ts","./node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/core/build/src/index.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/timedevent.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/export/readablespan.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/span.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/spanprocessor.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/idgenerator.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/sampler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/types.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/export/spanexporter.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/basictracerprovider.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/tracer.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/export/batchspanprocessorbase.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/platform/node/export/batchspanprocessor.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/platform/node/randomidgenerator.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/platform/node/index.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/platform/index.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/export/consolespanexporter.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/export/inmemoryspanexporter.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/export/simplespanprocessor.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/export/noopspanprocessor.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/sampler/alwaysoffsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/sampler/alwaysonsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/sampler/parentbasedsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/sampler/traceidratiobasedsampler.d.ts","./node_modules/@opentelemetry/sdk-trace-base/build/src/index.d.ts","./src/utils/tracing.ts","./src/tools/mapboxapibasedtool.ts","./src/schemas/shared.ts","./src/tools/category-list-tool/categorylisttool.input.schema.ts","./src/tools/category-list-tool/categorylisttool.output.schema.ts","./src/tools/category-list-tool/categorylisttool.ts","./src/tools/category-search-tool/categorysearchtool.input.schema.ts","./src/tools/category-search-tool/categorysearchtool.output.schema.ts","./src/schemas/geojson.ts","./src/tools/category-search-tool/categorysearchtool.ts","./src/tools/directions-tool/directionstool.input.schema.ts","./src/tools/directions-tool/cleanresponsedata.ts","./src/utils/dateutils.ts","./src/tools/directions-tool/directionstool.output.schema.ts","./src/tools/directions-tool/directionstool.ts","./src/tools/isochrone-tool/isochronetool.input.schema.ts","./src/tools/isochrone-tool/isochronetool.output.schema.ts","./src/tools/isochrone-tool/isochronetool.ts","./src/tools/map-matching-tool/mapmatchingtool.input.schema.ts","./src/tools/map-matching-tool/mapmatchingtool.output.schema.ts","./src/tools/map-matching-tool/mapmatchingtool.ts","./src/tools/matrix-tool/matrixtool.input.schema.ts","./src/tools/matrix-tool/matrixtool.output.schema.ts","./src/tools/matrix-tool/matrixtool.ts","./src/tools/optimization-tool/optimizationtool.input.schema.ts","./src/tools/optimization-tool/optimizationtool.output.schema.ts","./src/tools/optimization-tool/optimizationtool.ts","./src/tools/resource-reader-tool/resourcereadertool.input.schema.ts","./src/tools/resource-reader-tool/resourcereadertool.output.schema.ts","./src/resources/baseresource.ts","./src/resources/mapboxapibasedresource.ts","./src/resources/category-list/categorylistresource.ts","./src/utils/httppipeline.ts","./src/resources/resourceregistry.ts","./src/tools/resource-reader-tool/resourcereadertool.ts","./src/tools/reverse-geocode-tool/reversegeocodetool.input.schema.ts","./src/tools/reverse-geocode-tool/reversegeocodetool.output.schema.ts","./src/tools/reverse-geocode-tool/reversegeocodetool.ts","./node_modules/@mcp-ui/server/dist/src/types.d.ts","./node_modules/@mcp-ui/server/dist/src/utils.d.ts","./node_modules/@mcp-ui/server/dist/src/adapters/appssdk/types.d.ts","./node_modules/@mcp-ui/server/dist/src/adapters/appssdk/adapter.d.ts","./node_modules/@mcp-ui/server/dist/src/adapters/appssdk/index.d.ts","./node_modules/@mcp-ui/server/dist/src/adapters/index.d.ts","./node_modules/@mcp-ui/server/dist/src/index.d.ts","./src/tools/static-map-image-tool/staticmapimagetool.input.schema.ts","./src/tools/static-map-image-tool/staticmapimagetool.ts","./src/tools/search-and-geocode-tool/searchandgeocodetool.input.schema.ts","./src/tools/search-and-geocode-tool/searchandgeocodetool.output.schema.ts","./src/tools/search-and-geocode-tool/searchandgeocodetool.ts","./src/tools/version-tool/versiontool.input.schema.ts","./src/tools/version-tool/versiontool.output.schema.ts","./src/tools/version-tool/versiontool.ts","./src/tools/toolregistry.ts","./src/config/toolconfig.ts","./src/prompts/baseprompt.ts","./src/prompts/findplacesnearbyprompt.ts","./src/prompts/getdirectionsprompt.ts","./src/prompts/showreachableareasprompt.ts","./src/prompts/promptregistry.ts","./src/tools/optimization-tool/optimizationtask.ts","./src/index.ts","./src/tools/validateoutput.ts","./src/utils/versionutils-cjs.cts","./node_modules/@types/bunyan/index.d.ts","./node_modules/@types/deep-eql/index.d.ts","./node_modules/@types/chai/index.d.ts","./node_modules/@types/estree/index.d.ts","./node_modules/@types/fined/index.d.ts","./node_modules/rxjs/dist/types/internal/subscription.d.ts","./node_modules/rxjs/dist/types/internal/subscriber.d.ts","./node_modules/rxjs/dist/types/internal/operator.d.ts","./node_modules/rxjs/dist/types/internal/observable.d.ts","./node_modules/rxjs/dist/types/internal/types.d.ts","./node_modules/rxjs/dist/types/internal/operators/audit.d.ts","./node_modules/rxjs/dist/types/internal/operators/audittime.d.ts","./node_modules/rxjs/dist/types/internal/operators/buffer.d.ts","./node_modules/rxjs/dist/types/internal/operators/buffercount.d.ts","./node_modules/rxjs/dist/types/internal/operators/buffertime.d.ts","./node_modules/rxjs/dist/types/internal/operators/buffertoggle.d.ts","./node_modules/rxjs/dist/types/internal/operators/bufferwhen.d.ts","./node_modules/rxjs/dist/types/internal/operators/catcherror.d.ts","./node_modules/rxjs/dist/types/internal/operators/combinelatestall.d.ts","./node_modules/rxjs/dist/types/internal/operators/combineall.d.ts","./node_modules/rxjs/dist/types/internal/operators/combinelatest.d.ts","./node_modules/rxjs/dist/types/internal/operators/combinelatestwith.d.ts","./node_modules/rxjs/dist/types/internal/operators/concat.d.ts","./node_modules/rxjs/dist/types/internal/operators/concatall.d.ts","./node_modules/rxjs/dist/types/internal/operators/concatmap.d.ts","./node_modules/rxjs/dist/types/internal/operators/concatmapto.d.ts","./node_modules/rxjs/dist/types/internal/operators/concatwith.d.ts","./node_modules/rxjs/dist/types/internal/operators/connect.d.ts","./node_modules/rxjs/dist/types/internal/operators/count.d.ts","./node_modules/rxjs/dist/types/internal/operators/debounce.d.ts","./node_modules/rxjs/dist/types/internal/operators/debouncetime.d.ts","./node_modules/rxjs/dist/types/internal/operators/defaultifempty.d.ts","./node_modules/rxjs/dist/types/internal/operators/delay.d.ts","./node_modules/rxjs/dist/types/internal/operators/delaywhen.d.ts","./node_modules/rxjs/dist/types/internal/operators/dematerialize.d.ts","./node_modules/rxjs/dist/types/internal/operators/distinct.d.ts","./node_modules/rxjs/dist/types/internal/operators/distinctuntilchanged.d.ts","./node_modules/rxjs/dist/types/internal/operators/distinctuntilkeychanged.d.ts","./node_modules/rxjs/dist/types/internal/operators/elementat.d.ts","./node_modules/rxjs/dist/types/internal/operators/endwith.d.ts","./node_modules/rxjs/dist/types/internal/operators/every.d.ts","./node_modules/rxjs/dist/types/internal/operators/exhaustall.d.ts","./node_modules/rxjs/dist/types/internal/operators/exhaust.d.ts","./node_modules/rxjs/dist/types/internal/operators/exhaustmap.d.ts","./node_modules/rxjs/dist/types/internal/operators/expand.d.ts","./node_modules/rxjs/dist/types/internal/operators/filter.d.ts","./node_modules/rxjs/dist/types/internal/operators/finalize.d.ts","./node_modules/rxjs/dist/types/internal/operators/find.d.ts","./node_modules/rxjs/dist/types/internal/operators/findindex.d.ts","./node_modules/rxjs/dist/types/internal/operators/first.d.ts","./node_modules/rxjs/dist/types/internal/subject.d.ts","./node_modules/rxjs/dist/types/internal/operators/groupby.d.ts","./node_modules/rxjs/dist/types/internal/operators/ignoreelements.d.ts","./node_modules/rxjs/dist/types/internal/operators/isempty.d.ts","./node_modules/rxjs/dist/types/internal/operators/last.d.ts","./node_modules/rxjs/dist/types/internal/operators/map.d.ts","./node_modules/rxjs/dist/types/internal/operators/mapto.d.ts","./node_modules/rxjs/dist/types/internal/notification.d.ts","./node_modules/rxjs/dist/types/internal/operators/materialize.d.ts","./node_modules/rxjs/dist/types/internal/operators/max.d.ts","./node_modules/rxjs/dist/types/internal/operators/merge.d.ts","./node_modules/rxjs/dist/types/internal/operators/mergeall.d.ts","./node_modules/rxjs/dist/types/internal/operators/mergemap.d.ts","./node_modules/rxjs/dist/types/internal/operators/flatmap.d.ts","./node_modules/rxjs/dist/types/internal/operators/mergemapto.d.ts","./node_modules/rxjs/dist/types/internal/operators/mergescan.d.ts","./node_modules/rxjs/dist/types/internal/operators/mergewith.d.ts","./node_modules/rxjs/dist/types/internal/operators/min.d.ts","./node_modules/rxjs/dist/types/internal/observable/connectableobservable.d.ts","./node_modules/rxjs/dist/types/internal/operators/multicast.d.ts","./node_modules/rxjs/dist/types/internal/operators/observeon.d.ts","./node_modules/rxjs/dist/types/internal/operators/onerrorresumenextwith.d.ts","./node_modules/rxjs/dist/types/internal/operators/pairwise.d.ts","./node_modules/rxjs/dist/types/internal/operators/partition.d.ts","./node_modules/rxjs/dist/types/internal/operators/pluck.d.ts","./node_modules/rxjs/dist/types/internal/operators/publish.d.ts","./node_modules/rxjs/dist/types/internal/operators/publishbehavior.d.ts","./node_modules/rxjs/dist/types/internal/operators/publishlast.d.ts","./node_modules/rxjs/dist/types/internal/operators/publishreplay.d.ts","./node_modules/rxjs/dist/types/internal/operators/race.d.ts","./node_modules/rxjs/dist/types/internal/operators/racewith.d.ts","./node_modules/rxjs/dist/types/internal/operators/reduce.d.ts","./node_modules/rxjs/dist/types/internal/operators/repeat.d.ts","./node_modules/rxjs/dist/types/internal/operators/repeatwhen.d.ts","./node_modules/rxjs/dist/types/internal/operators/retry.d.ts","./node_modules/rxjs/dist/types/internal/operators/retrywhen.d.ts","./node_modules/rxjs/dist/types/internal/operators/refcount.d.ts","./node_modules/rxjs/dist/types/internal/operators/sample.d.ts","./node_modules/rxjs/dist/types/internal/operators/sampletime.d.ts","./node_modules/rxjs/dist/types/internal/operators/scan.d.ts","./node_modules/rxjs/dist/types/internal/operators/sequenceequal.d.ts","./node_modules/rxjs/dist/types/internal/operators/share.d.ts","./node_modules/rxjs/dist/types/internal/operators/sharereplay.d.ts","./node_modules/rxjs/dist/types/internal/operators/single.d.ts","./node_modules/rxjs/dist/types/internal/operators/skip.d.ts","./node_modules/rxjs/dist/types/internal/operators/skiplast.d.ts","./node_modules/rxjs/dist/types/internal/operators/skipuntil.d.ts","./node_modules/rxjs/dist/types/internal/operators/skipwhile.d.ts","./node_modules/rxjs/dist/types/internal/operators/startwith.d.ts","./node_modules/rxjs/dist/types/internal/operators/subscribeon.d.ts","./node_modules/rxjs/dist/types/internal/operators/switchall.d.ts","./node_modules/rxjs/dist/types/internal/operators/switchmap.d.ts","./node_modules/rxjs/dist/types/internal/operators/switchmapto.d.ts","./node_modules/rxjs/dist/types/internal/operators/switchscan.d.ts","./node_modules/rxjs/dist/types/internal/operators/take.d.ts","./node_modules/rxjs/dist/types/internal/operators/takelast.d.ts","./node_modules/rxjs/dist/types/internal/operators/takeuntil.d.ts","./node_modules/rxjs/dist/types/internal/operators/takewhile.d.ts","./node_modules/rxjs/dist/types/internal/operators/tap.d.ts","./node_modules/rxjs/dist/types/internal/operators/throttle.d.ts","./node_modules/rxjs/dist/types/internal/operators/throttletime.d.ts","./node_modules/rxjs/dist/types/internal/operators/throwifempty.d.ts","./node_modules/rxjs/dist/types/internal/operators/timeinterval.d.ts","./node_modules/rxjs/dist/types/internal/operators/timeout.d.ts","./node_modules/rxjs/dist/types/internal/operators/timeoutwith.d.ts","./node_modules/rxjs/dist/types/internal/operators/timestamp.d.ts","./node_modules/rxjs/dist/types/internal/operators/toarray.d.ts","./node_modules/rxjs/dist/types/internal/operators/window.d.ts","./node_modules/rxjs/dist/types/internal/operators/windowcount.d.ts","./node_modules/rxjs/dist/types/internal/operators/windowtime.d.ts","./node_modules/rxjs/dist/types/internal/operators/windowtoggle.d.ts","./node_modules/rxjs/dist/types/internal/operators/windowwhen.d.ts","./node_modules/rxjs/dist/types/internal/operators/withlatestfrom.d.ts","./node_modules/rxjs/dist/types/internal/operators/zip.d.ts","./node_modules/rxjs/dist/types/internal/operators/zipall.d.ts","./node_modules/rxjs/dist/types/internal/operators/zipwith.d.ts","./node_modules/rxjs/dist/types/operators/index.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/action.d.ts","./node_modules/rxjs/dist/types/internal/scheduler.d.ts","./node_modules/rxjs/dist/types/internal/testing/testmessage.d.ts","./node_modules/rxjs/dist/types/internal/testing/subscriptionlog.d.ts","./node_modules/rxjs/dist/types/internal/testing/subscriptionloggable.d.ts","./node_modules/rxjs/dist/types/internal/testing/coldobservable.d.ts","./node_modules/rxjs/dist/types/internal/testing/hotobservable.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/asyncscheduler.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/timerhandle.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/asyncaction.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/virtualtimescheduler.d.ts","./node_modules/rxjs/dist/types/internal/testing/testscheduler.d.ts","./node_modules/rxjs/dist/types/testing/index.d.ts","./node_modules/rxjs/dist/types/internal/symbol/observable.d.ts","./node_modules/rxjs/dist/types/internal/observable/dom/animationframes.d.ts","./node_modules/rxjs/dist/types/internal/behaviorsubject.d.ts","./node_modules/rxjs/dist/types/internal/replaysubject.d.ts","./node_modules/rxjs/dist/types/internal/asyncsubject.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/asapscheduler.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/asap.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/async.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/queuescheduler.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/queue.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/animationframescheduler.d.ts","./node_modules/rxjs/dist/types/internal/scheduler/animationframe.d.ts","./node_modules/rxjs/dist/types/internal/util/identity.d.ts","./node_modules/rxjs/dist/types/internal/util/pipe.d.ts","./node_modules/rxjs/dist/types/internal/util/noop.d.ts","./node_modules/rxjs/dist/types/internal/util/isobservable.d.ts","./node_modules/rxjs/dist/types/internal/lastvaluefrom.d.ts","./node_modules/rxjs/dist/types/internal/firstvaluefrom.d.ts","./node_modules/rxjs/dist/types/internal/util/argumentoutofrangeerror.d.ts","./node_modules/rxjs/dist/types/internal/util/emptyerror.d.ts","./node_modules/rxjs/dist/types/internal/util/notfounderror.d.ts","./node_modules/rxjs/dist/types/internal/util/objectunsubscribederror.d.ts","./node_modules/rxjs/dist/types/internal/util/sequenceerror.d.ts","./node_modules/rxjs/dist/types/internal/util/unsubscriptionerror.d.ts","./node_modules/rxjs/dist/types/internal/observable/bindcallback.d.ts","./node_modules/rxjs/dist/types/internal/observable/bindnodecallback.d.ts","./node_modules/rxjs/dist/types/internal/anycatcher.d.ts","./node_modules/rxjs/dist/types/internal/observable/combinelatest.d.ts","./node_modules/rxjs/dist/types/internal/observable/concat.d.ts","./node_modules/rxjs/dist/types/internal/observable/connectable.d.ts","./node_modules/rxjs/dist/types/internal/observable/defer.d.ts","./node_modules/rxjs/dist/types/internal/observable/empty.d.ts","./node_modules/rxjs/dist/types/internal/observable/forkjoin.d.ts","./node_modules/rxjs/dist/types/internal/observable/from.d.ts","./node_modules/rxjs/dist/types/internal/observable/fromevent.d.ts","./node_modules/rxjs/dist/types/internal/observable/fromeventpattern.d.ts","./node_modules/rxjs/dist/types/internal/observable/generate.d.ts","./node_modules/rxjs/dist/types/internal/observable/iif.d.ts","./node_modules/rxjs/dist/types/internal/observable/interval.d.ts","./node_modules/rxjs/dist/types/internal/observable/merge.d.ts","./node_modules/rxjs/dist/types/internal/observable/never.d.ts","./node_modules/rxjs/dist/types/internal/observable/of.d.ts","./node_modules/rxjs/dist/types/internal/observable/onerrorresumenext.d.ts","./node_modules/rxjs/dist/types/internal/observable/pairs.d.ts","./node_modules/rxjs/dist/types/internal/observable/partition.d.ts","./node_modules/rxjs/dist/types/internal/observable/race.d.ts","./node_modules/rxjs/dist/types/internal/observable/range.d.ts","./node_modules/rxjs/dist/types/internal/observable/throwerror.d.ts","./node_modules/rxjs/dist/types/internal/observable/timer.d.ts","./node_modules/rxjs/dist/types/internal/observable/using.d.ts","./node_modules/rxjs/dist/types/internal/observable/zip.d.ts","./node_modules/rxjs/dist/types/internal/scheduled/scheduled.d.ts","./node_modules/rxjs/dist/types/internal/config.d.ts","./node_modules/rxjs/dist/types/index.d.ts","./node_modules/@types/through/index.d.ts","./node_modules/@types/inquirer/lib/objects/choice.d.ts","./node_modules/@types/inquirer/lib/objects/separator.d.ts","./node_modules/@types/inquirer/lib/objects/choices.d.ts","./node_modules/@types/inquirer/lib/utils/screen-manager.d.ts","./node_modules/@types/inquirer/lib/prompts/base.d.ts","./node_modules/@types/inquirer/lib/utils/paginator.d.ts","./node_modules/@types/inquirer/lib/prompts/checkbox.d.ts","./node_modules/@types/inquirer/lib/prompts/confirm.d.ts","./node_modules/@types/inquirer/lib/prompts/editor.d.ts","./node_modules/@types/inquirer/lib/prompts/expand.d.ts","./node_modules/@types/inquirer/lib/prompts/input.d.ts","./node_modules/@types/inquirer/lib/prompts/list.d.ts","./node_modules/@types/inquirer/lib/prompts/number.d.ts","./node_modules/@types/inquirer/lib/prompts/password.d.ts","./node_modules/@types/inquirer/lib/prompts/rawlist.d.ts","./node_modules/@types/inquirer/lib/ui/baseui.d.ts","./node_modules/@types/inquirer/lib/ui/bottom-bar.d.ts","./node_modules/@types/inquirer/lib/ui/prompt.d.ts","./node_modules/@types/inquirer/lib/utils/events.d.ts","./node_modules/@types/inquirer/lib/utils/readline.d.ts","./node_modules/@types/inquirer/index.d.ts","./node_modules/@types/json-schema/index.d.ts","./node_modules/@types/liftoff/index.d.ts","./node_modules/@types/mysql/index.d.ts","./node_modules/@types/pg-pool/index.d.ts","./node_modules/@types/tedious/index.d.ts"],"fileIdsList":[[245,288,917],[245,288,917,918],[245,288,915],[245,288,919],[245,288,915,916,920],[207,245,288],[195,207,209,212,245,288],[195,207,210,219,245,288],[195,207,211,212,216,245,288],[207,210,245,288],[245,288],[195,207,212,214,215,245,288],[195,207,208,210,212,216,217,218,245,288],[207,208,245,288,320],[140,194,245,288],[195,206,207,208,210,211,245,288],[205,206,245,288],[213,245,288],[245,288,388,389,390],[245,288,386,387,388,389,390,391,392,393,394,395],[245,288,387,388],[245,288,387,388,389],[245,288,387],[126,245,288],[245,288,388,389],[126,245,288,386],[85,245,288],[88,245,288],[93,95,245,288],[81,85,97,98,245,288],[108,111,117,119,245,288],[80,85,245,288],[79,245,288],[80,245,288],[87,245,288],[90,245,288],[80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,120,121,122,123,124,125,245,288],[96,245,288],[92,245,288],[93,245,288],[84,85,91,245,288],[92,93,245,288],[99,245,288],[120,245,288],[84,245,288],[85,102,105,245,288],[101,245,288],[102,245,288],[100,102,245,288],[85,105,107,108,109,245,288],[108,109,111,245,288],[85,100,103,106,113,245,288],[100,101,245,288],[82,83,100,102,103,104,245,288],[102,105,245,288],[83,100,103,106,245,288],[85,105,107,245,288],[108,109,245,288],[245,288,769],[126,245,288,511,515,579,584,590,594,600,604,608,612,618,623,627,630,634,638,642,646,650,654,658,663,666,671,675,679,683,687,691,695,706,710,714,718,723,727,732,736,740,745,768],[245,288,491,492,493],[245,288,489,490,491,492,493,494,495,496,497,498],[245,288,490,491],[245,288,490,491,492],[245,288,490],[245,288,491,492],[126,245,288,489],[245,288,501],[245,288,500,501,502,507,508,509,510],[126,245,288,499,500],[245,288,500],[245,288,506],[245,288,504,505],[245,288,476,500,503],[245,288,310],[126,245,288,499],[126,227,245,288],[227,245,288],[224,225,226,227,228,229,230,231,232,233,234,238,245,288,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360],[232,245,288],[245,288,342],[234,245,288],[235,236,237,239,245,288,339,340,341],[245,288,311,338],[238,245,288],[245,288,338],[245,288,807],[245,288,806],[245,288,805],[245,288,467,804],[245,288,444,445,446,447,448,449,450,451,452,453,458,459,460,461,462,463,464,465,466],[245,288,511,513],[245,288,513,514],[126,245,288,338,511],[245,288,577,578],[126,245,288,511,577],[126,245,288,511,576],[245,288,511,582],[245,288,582,583],[126,245,288,511,581],[245,288,587,588,589],[245,288,511,587],[126,245,288,499,511],[245,288,592,593],[245,288,511,592],[126,245,288,511],[245,288,595,599],[126,245,288,511,596,597],[245,288,596],[245,288,602,603],[245,288,511,602],[245,288,511],[245,288,606,607],[245,288,511,606],[245,288,610,611],[245,288,511,610],[245,288,614,615,616,617],[245,288,511,615],[126,245,288,511,614],[245,288,619,621,622],[245,288,511,621],[245,288,625,626],[126,245,288,511,625],[126,245,288,301,338,511],[245,288,629],[245,288,632,633],[245,288,511,632],[245,288,636,637],[245,288,511,636],[245,288,640,641],[245,288,511,644],[245,288,644,645],[126,245,288,303,338,511],[245,288,648,649],[245,288,511,648],[245,288,652,653],[245,288,511,652],[245,288,656,657],[245,288,511,656],[245,288,660,661,662],[245,288,511,660],[245,288,665],[245,288,669,670],[126,245,288,511,668,669],[245,288,673,674],[245,288,511,673],[245,288,677,678],[245,288,511,677],[245,288,685,686],[126,245,288,511,685],[245,288,681,682],[245,288,511,681],[245,288,689,690],[245,288,693,694],[245,288,703,704,705],[245,288,511,703],[126,245,288,511,702],[245,288,708,709],[245,288,511,708],[245,288,716,717],[245,288,511,716],[245,288,712,713],[245,288,511,712],[245,288,720,721,722],[245,288,511,720],[245,288,725,726],[245,288,729,730,731],[245,288,511,729],[245,288,734,735],[245,288,511,734],[245,288,738,739],[245,288,511,738],[245,288,743,744],[245,288,511,743],[245,288,474],[245,288,473,474,475,481,482,483,484],[126,245,288,396,473],[245,288,473],[245,288,480],[245,288,478,479],[245,288,473,476,477],[126,245,288,396],[245,288,303,305,338,801],[245,288,780],[245,288,780,781,797,798,799,800,801,802,803],[245,288,361,781,782,796],[245,288,781,796,797,800],[245,288,361,797],[126,245,288,783],[245,288,783,784,785,786,787,788,790,791,792,793,794,795],[245,288,411,442,467,786,787,788,793],[245,288,396,411,783,788],[245,288,783,785],[245,288,442,783,786],[245,288,783],[245,288,467,783,787],[245,288,748],[245,288,746,747],[245,288,746,747,748],[245,288,761,762,763,764,765],[245,288,760],[245,288,746,748,749],[245,288,753,754,755,756,757,758,759],[245,288,746,747,748,749,752,766,767],[245,288,751],[245,288,750],[245,288,747,748],[126,245,288,746,747],[245,288,385,399,400,403],[245,288,361,397,403],[245,288,361,397],[126,245,288,397,400],[126,245,288,361,384,396],[245,288,399,400,403],[245,288,385,397,399,400,401,402,403,404,405,406,410],[245,288,384,385,396,400],[245,288,385,396,400],[126,245,288,361,384,396,397,398],[126,245,288,399],[245,288,409],[245,288,385,407],[245,288,408],[245,288,384],[245,288,364],[245,288,362,363],[245,288,362,363,364],[245,288,377,378,379,380,381],[245,288,376],[245,288,362,364,365],[245,288,369,370,371,372,373,374,375],[245,288,362,363,364,365,368,382,383],[245,288,367],[245,288,366],[245,288,363,364],[126,245,288,362,363],[126,245,288,417,418,419,431],[126,245,288,417,418,419,422,423,431],[245,288,419,420,421,424,425,426],[126,245,288,417,418,431],[245,288,417,428,430],[245,288,430],[245,288,361,417,430,431,432,433],[245,288,361,417,430,431,433],[126,245,288,361,384,417,419,430],[245,288,361,417,428,430,431],[245,288,431],[245,288,417,428,430,431,432,434,435,436],[245,288,433,434,437],[245,288,417,418,419,428,429,430,431,432,433,434,437,438,439,440,441],[126,245,288,429],[126,245,288,384,429,435,437],[126,245,288,361],[245,288,418,419,427,430],[245,288,414,430],[245,288,414],[245,288,413,415,416,428,430],[126,245,288,361,384,411,442,467,470,486,487],[245,288,411,442,486],[126,245,288,384,411,442,467,485],[126,245,288,768,856,859,860,862],[126,245,288,854,855,856,859,860],[245,288,852,854,860],[126,245,288,854,855,856],[126,245,288,768,852,853],[126,245,288,854,855,856,860],[245,288,852,854],[245,288,853,854,855,856,857,858,859,860,861,862,867,868,869,870,871,872,873,874,875],[245,288,866],[245,288,859,863],[245,288,864,865],[245,288,857],[245,288,858],[126,245,288,858],[126,245,288,768,852,853,854,862],[126,245,288,854,855],[126,245,288,768,852,856,859,861],[126,245,288,768,856,857,858],[126,245,288,817],[245,288,817],[245,288,814,815,816,817,818,819,820,821,822,823,824,828,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851],[245,288,822],[245,288,833],[245,288,824],[245,288,825,826,827,829,830,831,832],[245,288,828],[245,288,467],[245,288,467,468,469],[245,288,467,468],[126,245,288,384,450,451,467],[126,245,288,447,448,449,450,451],[245,288,361,447,451],[126,245,288,447,448,449],[126,245,288,361,384,446],[126,245,288,447,448,449,451],[245,288,361,447],[245,288,457],[245,288,450,454],[245,288,455,456],[245,288,444],[245,288,445],[126,245,288,445],[126,245,288,361,384,446,447,453],[126,245,288,447,448],[126,245,288,361,384,449,450,452],[126,245,288,384,444,445,449],[245,288,775,776,777,810,811,812],[245,288,772,774,775,776,777],[245,288,773],[245,288,771],[245,288,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575],[245,288,519],[245,288,519,523],[245,288,517,519,521],[245,288,517,519],[245,288,519,525],[245,288,518,519],[245,288,530],[245,288,519,536,537,538],[245,288,519,540],[245,288,519,541,542,543,544,545,546,547,548,549,550,551,552,553],[245,288,519,522],[245,288,519,521],[245,288,519,530],[245,288,300,338],[245,288,942],[245,288,303,338],[245,288,315,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155],[245,288,1156],[245,288,1136,1137,1156],[245,288,315,1134,1139,1156],[245,288,315,1140,1141,1156],[245,288,315,1140,1156],[245,288,315,1134,1140,1156],[245,288,315,1146,1156],[245,288,315,1156],[245,288,315,1134],[245,288,1139],[245,288,315],[245,288,300,338,945],[245,288,300,320,328,338],[245,285,288],[245,287,288],[288],[245,288,293,323],[245,288,289,294,300,301,308,320,331],[245,288,289,290,300,308],[240,241,242,245,288],[245,288,291,332],[245,288,292,293,301,309],[245,288,293,320,328],[245,288,294,296,300,308],[245,287,288,295],[245,288,296,297],[245,288,300],[245,288,298,300],[245,287,288,300],[245,288,300,301,302,320,331],[245,288,300,301,302,315,320,323],[245,283,288,336],[245,283,288,296,300,303,308,320,331],[245,288,300,301,303,304,308,320,328,331],[245,288,303,305,320,328,331],[243,244,245,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337],[245,288,300,306],[245,288,307,331],[245,288,296,300,308,320],[245,288,309],[245,287,288,311],[245,285,286,287,288,289,290,291,292,293,294,295,296,297,298,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337],[245,288,313],[245,288,314],[245,288,300,315,316],[245,288,315,317,332,334],[245,288,300,320,321,323],[245,288,322,323],[245,288,320,321],[245,288,323],[245,288,324],[245,285,288,320],[245,288,300,326,327],[245,288,326,327],[245,288,293,308,320,328],[245,288,329],[245,288,308,330],[245,288,303,314,331],[245,288,293,332],[245,288,320,333],[245,288,307,334],[245,288,335],[245,288,293,300,302,311,320,331,334,336],[245,288,320,337],[245,288,702],[245,288,300,320,328,338,697,698,701,702],[245,288,300,328,338],[245,288,320,338],[245,288,338,698,699,700],[245,288,320,338,698],[245,288,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,962,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1015,1016,1017,1018,1019,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1065,1066,1067,1069,1078,1080,1081,1082,1083,1084,1085,1087,1088,1090,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133],[245,288,991],[245,288,947,950],[245,288,949],[245,288,949,950],[245,288,946,947,948,950],[245,288,947,949,950,1107],[245,288,950],[245,288,946,949,991],[245,288,949,950,1107],[245,288,949,1115],[245,288,947,949,950],[245,288,959],[245,288,982],[245,288,1003],[245,288,949,950,991],[245,288,950,998],[245,288,949,950,991,1009],[245,288,949,950,1009],[245,288,950,1050],[245,288,950,991],[245,288,946,950,1068],[245,288,946,950,1069],[245,288,1091],[245,288,1075,1077],[245,288,1086],[245,288,1075],[245,288,946,950,1068,1075,1076],[245,288,1068,1069,1077],[245,288,1089],[245,288,946,950,1075,1076,1077],[245,288,948,949,950],[245,288,946,950],[245,288,947,949,1069,1070,1071,1072],[245,288,991,1069,1070,1071,1072],[245,288,1069,1071],[245,288,949,1070,1071,1073,1074,1078],[245,288,946,949],[245,288,950,1093],[245,288,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,992,993,994,995,996,997,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066],[245,288,1079],[245,255,259,288,331],[245,255,288,320,331],[245,250,288],[245,252,255,288,328,331],[245,288,308,328],[245,250,288,338],[245,252,255,288,308,331],[245,247,248,251,254,288,300,320,331],[245,255,262,288],[245,247,253,288],[245,255,276,277,288],[245,251,255,288,323,331,338],[245,276,288,338],[245,249,250,288,338],[245,255,288],[245,249,250,251,252,253,254,255,256,257,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,277,278,279,280,281,282,288],[245,255,270,288],[245,255,262,263,288],[245,253,255,263,264,288],[245,254,288],[245,247,250,255,288],[245,255,259,263,264,288],[245,259,288],[245,253,255,258,288,331],[245,247,252,255,262,288],[245,288,320],[245,250,255,276,288,336,338],[139,245,288],[129,130,245,288],[127,128,129,131,132,137,245,288],[128,129,245,288],[137,245,288],[138,245,288],[129,245,288],[127,128,129,132,133,134,135,136,245,288],[127,128,139,245,288],[194,245,288],[194,198,245,288],[187,194,196,197,198,199,200,201,202,245,288],[203,245,288],[194,196,245,288],[194,197,245,288],[142,144,145,146,147,245,288],[142,144,146,147,245,288],[142,144,146,245,288],[142,144,145,147,245,288],[142,144,245,288],[142,143,144,145,146,147,148,149,187,188,189,190,191,192,193,245,288],[144,147,245,288],[141,142,143,145,146,147,245,288],[144,188,192,245,288],[144,145,146,147,245,288],[204,245,288],[146,245,288],[150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,245,288],[245,288,930],[126,207,219,220,221,245,288,301,310,332,809,877,909,910,930,931,936,937],[207,245,288,932],[245,288,933,934,935],[207,212,219,245,288],[207,223,245,288,907],[126,207,212,223,245,288,877,906],[245,288,908,909],[140,245,288],[140,207,212,219,245,288],[140,245,288,879],[207,223,245,288,878,880,881],[140,207,223,245,288,878,883,884,885],[140,245,288,887],[140,207,223,245,288,331,878,887,888,889,890],[140,207,223,245,288,878,892,893],[140,207,223,245,288,331,878,895,896],[126,140,207,212,222,223,245,288,877],[140,207,223,245,288,331,878,898,899],[140,210,219,223,245,288,901,902],[140,207,223,245,288,878,901,902],[207,212,222,245,288,904,905,910],[140,207,223,245,288,878,885,912,913],[140,207,223,245,288,878,885,924,925],[140,207,223,245,288,878,921,922,931],[245,288,882,886,891,894,897,900,903,909,911,914,923,926,929],[140,207,245,288],[126,207,222,245,288,809,877,927,928],[126,223,245,288,809],[126,223,245,288,488,768,770,778,808,809,813,876],[245,288,301,310],[245,288,301,310,331]],"fileInfos":[{"version":"69684132aeb9b5642cbcd9e22dff7818ff0ee1aa831728af0ecf97d3364d5546","affectsGlobalScope":true,"impliedFormat":1},{"version":"45b7ab580deca34ae9729e97c13cfd999df04416a79116c3bfb483804f85ded4","impliedFormat":1},{"version":"3facaf05f0c5fc569c5649dd359892c98a85557e3e0c847964caeb67076f4d75","impliedFormat":1},{"version":"e44bb8bbac7f10ecc786703fe0a6a4b952189f908707980ba8f3c8975a760962","impliedFormat":1},{"version":"5e1c4c362065a6b95ff952c0eab010f04dcd2c3494e813b493ecfd4fcb9fc0d8","impliedFormat":1},{"version":"68d73b4a11549f9c0b7d352d10e91e5dca8faa3322bfb77b661839c42b1ddec7","impliedFormat":1},{"version":"5efce4fc3c29ea84e8928f97adec086e3dc876365e0982cc8479a07954a3efd4","impliedFormat":1},{"version":"feecb1be483ed332fad555aff858affd90a48ab19ba7272ee084704eb7167569","impliedFormat":1},{"version":"ee7bad0c15b58988daa84371e0b89d313b762ab83cb5b31b8a2d1162e8eb41c2","impliedFormat":1},{"version":"27bdc30a0e32783366a5abeda841bc22757c1797de8681bbe81fbc735eeb1c10","impliedFormat":1},{"version":"8fd575e12870e9944c7e1d62e1f5a73fcf23dd8d3a321f2a2c74c20d022283fe","impliedFormat":1},{"version":"8bf8b5e44e3c9c36f98e1007e8b7018c0f38d8adc07aecef42f5200114547c70","impliedFormat":1},{"version":"c57796738e7f83dbc4b8e65132f11a377649c00dd3eee333f672b8f0a6bea671","affectsGlobalScope":true,"impliedFormat":1},{"version":"dc2df20b1bcdc8c2d34af4926e2c3ab15ffe1160a63e58b7e09833f616efff44","affectsGlobalScope":true,"impliedFormat":1},{"version":"515d0b7b9bea2e31ea4ec968e9edd2c39d3eebf4a2d5cbd04e88639819ae3b71","affectsGlobalScope":true,"impliedFormat":1},{"version":"0559b1f683ac7505ae451f9a96ce4c3c92bdc71411651ca6ddb0e88baaaad6a3","affectsGlobalScope":true,"impliedFormat":1},{"version":"0dc1e7ceda9b8b9b455c3a2d67b0412feab00bd2f66656cd8850e8831b08b537","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce691fb9e5c64efb9547083e4a34091bcbe5bdb41027e310ebba8f7d96a98671","affectsGlobalScope":true,"impliedFormat":1},{"version":"8d697a2a929a5fcb38b7a65594020fcef05ec1630804a33748829c5ff53640d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ff2a353abf8a80ee399af572debb8faab2d33ad38c4b4474cff7f26e7653b8d","affectsGlobalScope":true,"impliedFormat":1},{"version":"936e80ad36a2ee83fc3caf008e7c4c5afe45b3cf3d5c24408f039c1d47bdc1df","affectsGlobalScope":true,"impliedFormat":1},{"version":"d15bea3d62cbbdb9797079416b8ac375ae99162a7fba5de2c6c505446486ac0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"68d18b664c9d32a7336a70235958b8997ebc1c3b8505f4f1ae2b7e7753b87618","affectsGlobalScope":true,"impliedFormat":1},{"version":"eb3d66c8327153d8fa7dd03f9c58d351107fe824c79e9b56b462935176cdf12a","affectsGlobalScope":true,"impliedFormat":1},{"version":"38f0219c9e23c915ef9790ab1d680440d95419ad264816fa15009a8851e79119","affectsGlobalScope":true,"impliedFormat":1},{"version":"69ab18c3b76cd9b1be3d188eaf8bba06112ebbe2f47f6c322b5105a6fbc45a2e","affectsGlobalScope":true,"impliedFormat":1},{"version":"fef8cfad2e2dc5f5b3d97a6f4f2e92848eb1b88e897bb7318cef0e2820bceaab","affectsGlobalScope":true,"impliedFormat":1},{"version":"2f11ff796926e0832f9ae148008138ad583bd181899ab7dd768a2666700b1893","affectsGlobalScope":true,"impliedFormat":1},{"version":"4de680d5bb41c17f7f68e0419412ca23c98d5749dcaaea1896172f06435891fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"954296b30da6d508a104a3a0b5d96b76495c709785c1d11610908e63481ee667","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac9538681b19688c8eae65811b329d3744af679e0bdfa5d842d0e32524c73e1c","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a969edff4bd52585473d24995c5ef223f6652d6ef46193309b3921d65dd4376","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e9fbd7030c440b33d021da145d3232984c8bb7916f277e8ffd3dc2e3eae2bdb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811ec78f7fefcabbda4bfa93b3eb67d9ae166ef95f9bff989d964061cbf81a0c","affectsGlobalScope":true,"impliedFormat":1},{"version":"717937616a17072082152a2ef351cb51f98802fb4b2fdabd32399843875974ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"d7e7d9b7b50e5f22c915b525acc5a49a7a6584cf8f62d0569e557c5cfc4b2ac2","affectsGlobalScope":true,"impliedFormat":1},{"version":"71c37f4c9543f31dfced6c7840e068c5a5aacb7b89111a4364b1d5276b852557","affectsGlobalScope":true,"impliedFormat":1},{"version":"576711e016cf4f1804676043e6a0a5414252560eb57de9faceee34d79798c850","affectsGlobalScope":true,"impliedFormat":1},{"version":"89c1b1281ba7b8a96efc676b11b264de7a8374c5ea1e6617f11880a13fc56dc6","affectsGlobalScope":true,"impliedFormat":1},{"version":"74f7fa2d027d5b33eb0471c8e82a6c87216223181ec31247c357a3e8e2fddc5b","affectsGlobalScope":true,"impliedFormat":1},{"version":"d6d7ae4d1f1f3772e2a3cde568ed08991a8ae34a080ff1151af28b7f798e22ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"063600664504610fe3e99b717a1223f8b1900087fab0b4cad1496a114744f8df","affectsGlobalScope":true,"impliedFormat":1},{"version":"934019d7e3c81950f9a8426d093458b65d5aff2c7c1511233c0fd5b941e608ab","affectsGlobalScope":true,"impliedFormat":1},{"version":"52ada8e0b6e0482b728070b7639ee42e83a9b1c22d205992756fe020fd9f4a47","affectsGlobalScope":true,"impliedFormat":1},{"version":"3bdefe1bfd4d6dee0e26f928f93ccc128f1b64d5d501ff4a8cf3c6371200e5e6","affectsGlobalScope":true,"impliedFormat":1},{"version":"59fb2c069260b4ba00b5643b907ef5d5341b167e7d1dbf58dfd895658bda2867","affectsGlobalScope":true,"impliedFormat":1},{"version":"639e512c0dfc3fad96a84caad71b8834d66329a1f28dc95e3946c9b58176c73a","affectsGlobalScope":true,"impliedFormat":1},{"version":"368af93f74c9c932edd84c58883e736c9e3d53cec1fe24c0b0ff451f529ceab1","affectsGlobalScope":true,"impliedFormat":1},{"version":"af3dd424cf267428f30ccfc376f47a2c0114546b55c44d8c0f1d57d841e28d74","affectsGlobalScope":true,"impliedFormat":1},{"version":"995c005ab91a498455ea8dfb63aa9f83fa2ea793c3d8aa344be4a1678d06d399","affectsGlobalScope":true,"impliedFormat":1},{"version":"959d36cddf5e7d572a65045b876f2956c973a586da58e5d26cde519184fd9b8a","affectsGlobalScope":true,"impliedFormat":1},{"version":"965f36eae237dd74e6cca203a43e9ca801ce38824ead814728a2807b1910117d","affectsGlobalScope":true,"impliedFormat":1},{"version":"3925a6c820dcb1a06506c90b1577db1fdbf7705d65b62b99dce4be75c637e26b","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a3d63ef2b853447ec4f749d3f368ce642264246e02911fcb1590d8c161b8005","affectsGlobalScope":true,"impliedFormat":1},{"version":"b5ce7a470bc3628408429040c4e3a53a27755022a32fd05e2cb694e7015386c7","affectsGlobalScope":true,"impliedFormat":1},{"version":"8444af78980e3b20b49324f4a16ba35024fef3ee069a0eb67616ea6ca821c47a","affectsGlobalScope":true,"impliedFormat":1},{"version":"3287d9d085fbd618c3971944b65b4be57859f5415f495b33a6adc994edd2f004","affectsGlobalScope":true,"impliedFormat":1},{"version":"b4b67b1a91182421f5df999988c690f14d813b9850b40acd06ed44691f6727ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"df83c2a6c73228b625b0beb6669c7ee2a09c914637e2d35170723ad49c0f5cd4","affectsGlobalScope":true,"impliedFormat":1},{"version":"436aaf437562f276ec2ddbee2f2cdedac7664c1e4c1d2c36839ddd582eeb3d0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e3c06ea092138bf9fa5e874a1fdbc9d54805d074bee1de31b99a11e2fec239d","affectsGlobalScope":true,"impliedFormat":1},{"version":"87dc0f382502f5bbce5129bdc0aea21e19a3abbc19259e0b43ae038a9fc4e326","affectsGlobalScope":true,"impliedFormat":1},{"version":"b1cb28af0c891c8c96b2d6b7be76bd394fddcfdb4709a20ba05a7c1605eea0f9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2fef54945a13095fdb9b84f705f2b5994597640c46afeb2ce78352fab4cb3279","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac77cb3e8c6d3565793eb90a8373ee8033146315a3dbead3bde8db5eaf5e5ec6","affectsGlobalScope":true,"impliedFormat":1},{"version":"56e4ed5aab5f5920980066a9409bfaf53e6d21d3f8d020c17e4de584d29600ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ece9f17b3866cc077099c73f4983bddbcb1dc7ddb943227f1ec070f529dedd1","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a6282c8827e4b9a95f4bf4f5c205673ada31b982f50572d27103df8ceb8013c","affectsGlobalScope":true,"impliedFormat":1},{"version":"1c9319a09485199c1f7b0498f2988d6d2249793ef67edda49d1e584746be9032","affectsGlobalScope":true,"impliedFormat":1},{"version":"e3a2a0cee0f03ffdde24d89660eba2685bfbdeae955a6c67e8c4c9fd28928eeb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811c71eee4aa0ac5f7adf713323a5c41b0cf6c4e17367a34fbce379e12bbf0a4","affectsGlobalScope":true,"impliedFormat":1},{"version":"51ad4c928303041605b4d7ae32e0c1ee387d43a24cd6f1ebf4a2699e1076d4fa","affectsGlobalScope":true,"impliedFormat":1},{"version":"60037901da1a425516449b9a20073aa03386cce92f7a1fd902d7602be3a7c2e9","affectsGlobalScope":true,"impliedFormat":1},{"version":"d4b1d2c51d058fc21ec2629fff7a76249dec2e36e12960ea056e3ef89174080f","affectsGlobalScope":true,"impliedFormat":1},{"version":"22adec94ef7047a6c9d1af3cb96be87a335908bf9ef386ae9fd50eeb37f44c47","affectsGlobalScope":true,"impliedFormat":1},{"version":"4245fee526a7d1754529d19227ecbf3be066ff79ebb6a380d78e41648f2f224d","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e7f8264d0fb4c5339605a15daadb037bf238c10b654bb3eee14208f860a32ea","affectsGlobalScope":true,"impliedFormat":1},{"version":"782dec38049b92d4e85c1585fbea5474a219c6984a35b004963b00beb1aab538","affectsGlobalScope":true,"impliedFormat":1},{"version":"a4e9e0d92dcad2cb387a5f1bdffe621569052f2d80186e11973aa7080260d296","impliedFormat":1},{"version":"f6380cc36fc3efc70084d288d0a05d0a2e09da012ee3853f9d62431e7216f129","impliedFormat":1},{"version":"497c3e541b4acf6c5d5ba75b03569cfe5fe25c8a87e6c87f1af98da6a3e7b918","impliedFormat":1},{"version":"d9429b81edf2fb2abf1e81e9c2e92615f596ed3166673d9b69b84c369b15fdc0","impliedFormat":1},{"version":"7e22943ae4e474854ca0695ab750a8026f55bb94278331fda02a4fb42efce063","impliedFormat":1},{"version":"7da9ff3d9a7e62ddca6393a23e67296ab88f2fcb94ee5f7fb977fa8e478852ac","impliedFormat":1},{"version":"e1b45cc21ea200308cbc8abae2fb0cfd014cb5b0e1d1643bcc50afa5959b6d83","impliedFormat":1},{"version":"c9740b0ce7533ce6ba21a7d424e38d2736acdddeab2b1a814c00396e62cc2f10","impliedFormat":1},{"version":"b3c1f6a3fdbb04c6b244de6d5772ffdd9e962a2faea1440e410049c13e874b87","impliedFormat":1},{"version":"dcaa872d9b52b9409979170734bdfd38f846c32114d05b70640fd05140b171bb","impliedFormat":1},{"version":"6c434d20da381fcd2e8b924a3ec9b8653cf8bed8e0da648e91f4c984bd2a5a91","impliedFormat":1},{"version":"992419d044caf6b14946fa7b9463819ab2eeb7af7c04919cc2087ce354c92266","impliedFormat":1},{"version":"fa9815e9ce1330289a5c0192e2e91eb6178c0caa83c19fe0c6a9f67013fe795c","impliedFormat":1},{"version":"06384a1a73fcf4524952ecd0d6b63171c5d41dd23573907a91ef0a687ddb4a8c","impliedFormat":1},{"version":"34b1594ecf1c84bcc7a04d9f583afa6345a6fea27a52cf2685f802629219de45","impliedFormat":1},{"version":"d82c9ca830d7b94b7530a2c5819064d8255b93dfeddc5b2ebb8a09316f002c89","impliedFormat":1},{"version":"7e046b9634add57e512412a7881efbc14d44d1c65eadd35432412aa564537975","impliedFormat":1},{"version":"aac9079b9e2b5180036f27ab37cb3cf4fd19955be48ccc82eab3f092ee3d4026","impliedFormat":1},{"version":"3d9c38933bc69e0a885da20f019de441a3b5433ce041ba5b9d3a541db4b568cb","impliedFormat":1},{"version":"606aa2b74372221b0f79ca8ae3568629f444cc454aa59b032e4cb602308dec94","impliedFormat":1},{"version":"50474eaea72bfda85cc37ae6cd29f0556965c0849495d96c8c04c940ef3d2f44","impliedFormat":1},{"version":"b4874382f863cf7dc82b3d15aed1e1372ac3fede462065d5bfc8510c0d8f7b19","impliedFormat":1},{"version":"df10b4f781871afb72b2d648d497671190b16b679bf7533b744cc10b3c6bf7ea","impliedFormat":1},{"version":"1fdc28754c77e852c92087c789a1461aa6eed19c335dc92ce6b16a188e7ba305","impliedFormat":1},{"version":"a656dab1d502d4ddc845b66d8735c484bfebbf0b1eda5fb29729222675759884","impliedFormat":1},{"version":"465a79505258d251068dc0047a67a3605dd26e6b15e9ad2cec297442cbb58820","impliedFormat":1},{"version":"ddae22d9329db28ce3d80a2a53f99eaed66959c1c9cd719c9b744e5470579d2f","impliedFormat":1},{"version":"d0e25feadef054c6fc6a7f55ccc3b27b7216142106b9ff50f5e7b19d85c62ca7","impliedFormat":1},{"version":"111214009193320cacbae104e8281f6cb37788b52a6a84d259f9822c8c71f6ca","impliedFormat":1},{"version":"01c8e2c8984c96b9b48be20ee396bd3689a3a3e6add8d50fe8229a7d4e62ff45","impliedFormat":1},{"version":"a4a0800b592e533897b4967b00fb00f7cd48af9714d300767cc231271aa100af","impliedFormat":1},{"version":"20aa818c3e16e40586f2fa26327ea17242c8873fe3412a69ec68846017219314","impliedFormat":1},{"version":"f498532f53d54f831851990cb4bcd96063d73e302906fa07e2df24aa5935c7d1","impliedFormat":1},{"version":"5fd19dfde8de7a0b91df6a9bbdc44b648fd1f245cae9e8b8cf210d83ee06f106","impliedFormat":1},{"version":"3b8d6638c32e63ea0679eb26d1eb78534f4cc02c27b80f1c0a19f348774f5571","impliedFormat":1},{"version":"ce0da52e69bc3d82a7b5bc40da6baad08d3790de13ad35e89148a88055b46809","impliedFormat":1},{"version":"9e01233da81bfed887f8d9a70d1a26bf11b8ddff165806cc586c84980bf8fc24","impliedFormat":1},{"version":"214a6afbab8b285fc97eb3cece36cae65ea2fca3cbd0c017a96159b14050d202","impliedFormat":1},{"version":"14beeca2944b75b229c0549e0996dc4b7863e07257e0d359d63a7be49a6b86a4","impliedFormat":1},{"version":"f7bb9adb1daa749208b47d1313a46837e4d27687f85a3af7777fc1c9b3dc06b1","impliedFormat":1},{"version":"c549fe2f52101ffe47f58107c702af7cdcd42da8c80afd79f707d1c5d77d4b6e","impliedFormat":1},{"version":"3966ea9e1c1a5f6e636606785999734988e135541b79adc6b5d00abdc0f4bf05","impliedFormat":1},{"version":"0b60b69c957adb27f990fbc27ea4ac1064249400262d7c4c1b0a1687506b3406","impliedFormat":1},{"version":"12c26e5d1befc0ded725cee4c2316f276013e6f2eb545966562ae9a0c1931357","impliedFormat":1},{"version":"27b247363f1376c12310f73ebac6debcde009c0b95b65a8207e4fa90e132b30a","impliedFormat":1},{"version":"05bd302e2249da923048c09dc684d1d74cb205551a87f22fb8badc09ec532a08","impliedFormat":1},{"version":"fe930ec064571ab3b698b13bddf60a29abf9d2f36d51ab1ca0083b087b061f3a","impliedFormat":1},{"version":"6b85c4198e4b62b0056d55135ad95909adf1b95c9a86cdbed2c0f4cc1a902d53","impliedFormat":1},{"version":"d3cfde44f8089768ebb08098c96d01ca260b88bccf238d55eee93f1c620ff5a5","impliedFormat":1},{"version":"293eadad9dead44c6fd1db6de552663c33f215c55a1bfa2802a1bceed88ff0ec","impliedFormat":1},{"version":"54f6ec6ea75acea6eb23635617252d249145edbc7bcd9d53f2d70280d2aef953","impliedFormat":1},{"version":"c25ce98cca43a3bfa885862044be0d59557be4ecd06989b2001a83dcf69620fd","impliedFormat":1},{"version":"8e71e53b02c152a38af6aec45e288cc65bede077b92b9b43b3cb54a37978bb33","impliedFormat":1},{"version":"754a9396b14ca3a4241591afb4edc644b293ccc8a3397f49be4dfd520c08acb3","impliedFormat":1},{"version":"f672c876c1a04a223cf2023b3d91e8a52bb1544c576b81bf64a8fec82be9969c","impliedFormat":1},{"version":"e4b03ddcf8563b1c0aee782a185286ed85a255ce8a30df8453aade2188bbc904","impliedFormat":1},{"version":"de2316e90fc6d379d83002f04ad9698bc1e5285b4d52779778f454dd12ce9f44","impliedFormat":1},{"version":"25b3f581e12ede11e5739f57a86e8668fbc0124f6649506def306cad2c59d262","impliedFormat":1},{"version":"2da997a01a6aa5c5c09de5d28f0f4407b597c5e1aecfd32f1815809c532650a2","impliedFormat":1},{"version":"5d26d2e47e2352def36f89a3e8bf8581da22b7f857e07ef3114cd52cf4813445","impliedFormat":1},{"version":"3db2efd285e7328d8014b54a7fce3f4861ebcdc655df40517092ed0050983617","impliedFormat":1},{"version":"d5d39a24c759df40480a4bfc0daffd364489702fdbcbdfc1711cde34f8739995","impliedFormat":1},{"version":"309ebd217636d68cf8784cbc3272c16fb94fb8e969e18b6fe88c35200340aef1","impliedFormat":1},{"version":"a479e90c2ea2abbaf9a490be7dcf586436d7249fe2b07e9741477dd4f305c86e","impliedFormat":1},{"version":"ef9b6279acc69002a779d0172916ef22e8be5de2d2469ff2f4bb019a21e89de2","impliedFormat":1},{"version":"09bf1c0fddf3e5b88af1a0f1eca2cb2f0b0877bdc0e7dce9e07964b35130b4a0","affectsGlobalScope":true,"impliedFormat":1},{"version":"2b060d4870c5310da5674b70508f943f8fb0bb899397161d6745ebdff9e803ec","impliedFormat":1},{"version":"6c859096094c744d2dd7b733189293a5b2af535e15f7794e69a3b4288b70dcfc","impliedFormat":1},{"version":"b565fac07bdf5ae2dd19ea9b013e6bbd1381a4823df2e74045e666a7751d075a","impliedFormat":1},{"version":"716a022c6d311c8367d830d2839fe017699564de2d0f5446b4a6f3f022a5c0c6","impliedFormat":1},{"version":"c939cb12cb000b4ec9c3eca3fe7dee1fe373ccb801237631d9252bad10206d61","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"3b25e966fd93475d8ca2834194ea78321d741a21ca9d1f606b25ec99c1bbc29a","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"3b25e966fd93475d8ca2834194ea78321d741a21ca9d1f606b25ec99c1bbc29a","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"7ceb8bc679a90951354f89379bc37228e7cf87b753069cd7b62310d5cbbe1f11","impliedFormat":1},{"version":"e125ee5bd9c921ed2e27a13e89532c4c44ecad11711018916163f0e708faaf89","impliedFormat":1},{"version":"e50cc7d8f2afbd14b4b11b4db1f3018b224a5fa973ad77813c5899be4c7e5b91","impliedFormat":1},{"version":"80e653fbbec818eecfe95d182dc65a1d107b343d970159a71922ac4491caa0af","impliedFormat":1},{"version":"848a52ea026a326373fdc9c26620429cf1dadaafc923edb60c6daf548604fa99","impliedFormat":1},{"version":"79f58214fb0a3258879aa404cf5b3e9b57d50e20ca2f85343486c78a18e44563","impliedFormat":1},{"version":"02e75aceef20d8bfc6c625015a7c23a8a8ca3412bba55599f143057251b331a7","impliedFormat":1},{"version":"9048a2528d014161273178ece75386066d048ba4a56d9b7b4e8052ce4e3adb48","impliedFormat":1},{"version":"f5c8f2ef9603893e25ed86c7112cd2cc60d53e5387b9146c904bce3e707c55de","impliedFormat":1},{"version":"0648a8c200b5544e30677f7f7059b1e384d6cab716c82659716457e3f317ebae","impliedFormat":99},{"version":"dc01facbb7d88bc5e2eabb7c6eee80a0241538d50a5c3b210fb745683faa1dab","impliedFormat":1},{"version":"5c5197a46686814821229b28e4cfd601ef0a32f2d2d29b9a99050bac0ab03c99","impliedFormat":1},{"version":"ce5a5332166ee959e9377b54c80cea461e86e452f40f2a0ee70fd73f2585522f","impliedFormat":1},{"version":"2c6c3af3957e38e6a5190258a666a06893ba5a11e3501585243129afecefd037","impliedFormat":1},{"version":"13e5ea921d6f62171aab19f33a6690e3c6658eecd2e5672425e49ac30d4305e6","impliedFormat":1},{"version":"1e28020a23b28743d5bd708b9e4c7b75fdff606aa080fbaf5b8db3600d5c99cf","impliedFormat":1},{"version":"73f06035e9eff53a009df4ab928076eea25134f111dffcdccd90856ce25ff3be","impliedFormat":1},{"version":"b91f4919c0972651793b78baf5a06fa9a7a412d22af20122e011d0ec21506c41","impliedFormat":1},{"version":"d49030b9a324bab9bcf9f663a70298391b0f5a25328409174d86617512bf3037","impliedFormat":1},{"version":"a4b634bb8c97cc700dbf165f3bb0095ec669042da72eaf28a7c5e2ddd98169ce","impliedFormat":1},{"version":"f17ed72d1b1882ab6dc66d45e699f757d15bba0807af2fc9c3ec98fe367611c1","impliedFormat":99},{"version":"1261246aed09870ea204dd3ab6958463d4a1bb91da9d34ed17615fbe34699440","impliedFormat":99},{"version":"7bb43a0f0180ad87b0a944ef95be8615d4c1d621a93ae503a8fcdee2027243ef","impliedFormat":99},{"version":"ba678532514244768286bdfdc82b33f072d5de4e9d281a75bcccdba9970788d7","impliedFormat":99},{"version":"0b79f95a79497386c50f38bafbbf59154619e51d7bbe5acf61cd376d3c9d77b9","impliedFormat":99},{"version":"5993793a23b298afd20c2e1cd2bf8468cc7e9415d314d0771e93dd8b2e389d28","impliedFormat":99},{"version":"2ac574152c07fe5bfea9ce46e9452a28f849ec11c7bbbdc399b7bd1aeab9455f","impliedFormat":99},{"version":"104fae9b53b5eaa040d9ce626e1bf0b3e6e27d269a899a98a4a28358cdcbc155","impliedFormat":99},{"version":"50a6aa665f3a2e769a4d683f9f74cd15164d0947fb957d8016331b170ab8b643","impliedFormat":99},{"version":"497b23b09c82d778effca827e408d787634d827c7f2fe63544b19f2815ecdd68","impliedFormat":99},{"version":"33aa2f336bb0bc598652ddd1ad3095ef7a14e4dbed9cf829fa9357e989fff31a","impliedFormat":99},{"version":"d691e546590145171d00d78b341bd3ca4844c96eb34f870be84058a1cab585c3","impliedFormat":99},{"version":"c9d12ca3f67129b3ed2b81bf54537c970673cedd05ba28fbeba70c1e8aff684b","impliedFormat":99},{"version":"6f0b69f7afb2ff04a4b73fae6b43476c14349a438881c7a8c3d34cbad2c2bf3b","impliedFormat":99},{"version":"f55b797d46c4268b2e42961be04e99ad10ccbe55f2cb87fc99b82979fb28121f","impliedFormat":99},{"version":"254e8e22983118bd0c2d5a7ccce15504d0b3ced0fb5ad7b187c261d7899d7451","impliedFormat":99},{"version":"10ce553a7102920c036c0ed6de73cd4400c0ff5370a7a642f9b6311fa9e7ab42","signature":"5b7badabde417f0acc92782a9f604f2368b2a801d06c77ada1a5d537aeb47413","impliedFormat":99},{"version":"550951a8491d6da38e6b4d8e1524ac90df1585ac7f5c785166c9f17f10001135","signature":"021cfbf455383a2924778dd049b50c30a9ccc726e80e878eb3189a2a91d5e1d2","impliedFormat":99},{"version":"dbfa8af0021ddb4ddebe1b279b46e5bccf05f473c178041b3b859b1d535dd1e5","impliedFormat":1},{"version":"7ab2721483b53d5551175e29a383283242704c217695378e2462c16de44aff1a","impliedFormat":1},{"version":"ebafa97de59db1a26c71b59fa4ee674c91d85a24a29d715e29e4db58b5ff267d","impliedFormat":1},{"version":"16ba4c64c1c5a52cc6f1b4e1fa084b82b273a5310ae7bc1206c877be7de45d03","impliedFormat":1},{"version":"1538a8a715f841d0a130b6542c72aea01d55d6aa515910dfef356185acf3b252","impliedFormat":1},{"version":"68eeb3d2d97a86a2c037e1268f059220899861172e426b656740effd93f63a45","impliedFormat":1},{"version":"d5689cb5d542c8e901195d8df6c2011a516d5f14c6a2283ffdaae381f5c38c01","impliedFormat":1},{"version":"9974861cff8cb8736b8784879fe44daca78bc2e621fc7828b0c2cf03b184a9e5","impliedFormat":1},{"version":"675e5ac3410a9a186dd746e7b2b5612fa77c49f534283876ffc0c58257da2be7","impliedFormat":1},{"version":"951a8f023da2905ae4d00418539ff190c01d8a34c8d8616b3982ff50c994bbb6","impliedFormat":1},{"version":"8cfe5ad847a1e073099e64ce97e91c0c14d8d88aaefcff5073aa4dda17f3067f","impliedFormat":1},{"version":"955c80622de0580d047d9ccdb1590e589c666c9240f63d2c5159e0732ab0a02e","impliedFormat":1},{"version":"e4b31fc1a59b688d30ff95f5a511bfb05e340097981e0de3e03419cbefe36c0e","impliedFormat":1},{"version":"16a2ac3ba047eddda3a381e6dac30b2e14e84459967f86013c97b5d8959276f3","impliedFormat":1},{"version":"45f1c5dbeb6bbf16c32492ba182c17449ab18d2d448cc2751c779275be0713d8","impliedFormat":1},{"version":"23d9f0f07f316bc244ffaaec77ae8e75219fb8b6697d1455916bc2153a312916","impliedFormat":1},{"version":"70521b6ab0dcba37539e5303104f29b721bfb2940b2776da4cc818c07e1fefc1","affectsGlobalScope":true,"impliedFormat":1},{"version":"030e350db2525514580ed054f712ffb22d273e6bc7eddc1bb7eda1e0ba5d395e","affectsGlobalScope":true,"impliedFormat":1},{"version":"d153a11543fd884b596587ccd97aebbeed950b26933ee000f94009f1ab142848","affectsGlobalScope":true,"impliedFormat":1},{"version":"21d819c173c0cf7cc3ce57c3276e77fd9a8a01d35a06ad87158781515c9a438a","impliedFormat":1},{"version":"a79e62f1e20467e11a904399b8b18b18c0c6eea6b50c1168bf215356d5bebfaf","affectsGlobalScope":true,"impliedFormat":1},{"version":"d802f0e6b5188646d307f070d83512e8eb94651858de8a82d1e47f60fb6da4e2","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e9c23ba78aabc2e0a27033f18737a6df754067731e69dc5f52823957d60a4b6","impliedFormat":1},{"version":"5929864ce17fba74232584d90cb721a89b7ad277220627cc97054ba15a98ea8f","impliedFormat":1},{"version":"763fe0f42b3d79b440a9b6e51e9ba3f3f91352469c1e4b3b67bfa4ff6352f3f4","impliedFormat":1},{"version":"25c8056edf4314820382a5fdb4bb7816999acdcb929c8f75e3f39473b87e85bc","impliedFormat":1},{"version":"c464d66b20788266e5353b48dc4aa6bc0dc4a707276df1e7152ab0c9ae21fad8","impliedFormat":1},{"version":"78d0d27c130d35c60b5e5566c9f1e5be77caf39804636bc1a40133919a949f21","impliedFormat":1},{"version":"c6fd2c5a395f2432786c9cb8deb870b9b0e8ff7e22c029954fabdd692bff6195","impliedFormat":1},{"version":"1d6e127068ea8e104a912e42fc0a110e2aa5a66a356a917a163e8cf9a65e4a75","impliedFormat":1},{"version":"5ded6427296cdf3b9542de4471d2aa8d3983671d4cac0f4bf9c637208d1ced43","impliedFormat":1},{"version":"7f182617db458e98fc18dfb272d40aa2fff3a353c44a89b2c0ccb3937709bfb5","impliedFormat":1},{"version":"cadc8aced301244057c4e7e73fbcae534b0f5b12a37b150d80e5a45aa4bebcbd","impliedFormat":1},{"version":"385aab901643aa54e1c36f5ef3107913b10d1b5bb8cbcd933d4263b80a0d7f20","impliedFormat":1},{"version":"9670d44354bab9d9982eca21945686b5c24a3f893db73c0dae0fd74217a4c219","impliedFormat":1},{"version":"0b8a9268adaf4da35e7fa830c8981cfa22adbbe5b3f6f5ab91f6658899e657a7","impliedFormat":1},{"version":"11396ed8a44c02ab9798b7dca436009f866e8dae3c9c25e8c1fbc396880bf1bb","impliedFormat":1},{"version":"ba7bc87d01492633cb5a0e5da8a4a42a1c86270e7b3d2dea5d156828a84e4882","impliedFormat":1},{"version":"4893a895ea92c85345017a04ed427cbd6a1710453338df26881a6019432febdd","impliedFormat":1},{"version":"c21dc52e277bcfc75fac0436ccb75c204f9e1b3fa5e12729670910639f27343e","impliedFormat":1},{"version":"13f6f39e12b1518c6650bbb220c8985999020fe0f21d818e28f512b7771d00f9","impliedFormat":1},{"version":"9b5369969f6e7175740bf51223112ff209f94ba43ecd3bb09eefff9fd675624a","impliedFormat":1},{"version":"4fe9e626e7164748e8769bbf74b538e09607f07ed17c2f20af8d680ee49fc1da","impliedFormat":1},{"version":"24515859bc0b836719105bb6cc3d68255042a9f02a6022b3187948b204946bd2","impliedFormat":1},{"version":"ea0148f897b45a76544ae179784c95af1bd6721b8610af9ffa467a518a086a43","impliedFormat":1},{"version":"24c6a117721e606c9984335f71711877293a9651e44f59f3d21c1ea0856f9cc9","impliedFormat":1},{"version":"dd3273ead9fbde62a72949c97dbec2247ea08e0c6952e701a483d74ef92d6a17","impliedFormat":1},{"version":"405822be75ad3e4d162e07439bac80c6bcc6dbae1929e179cf467ec0b9ee4e2e","impliedFormat":1},{"version":"0db18c6e78ea846316c012478888f33c11ffadab9efd1cc8bcc12daded7a60b6","impliedFormat":1},{"version":"e61be3f894b41b7baa1fbd6a66893f2579bfad01d208b4ff61daef21493ef0a8","impliedFormat":1},{"version":"bd0532fd6556073727d28da0edfd1736417a3f9f394877b6d5ef6ad88fba1d1a","impliedFormat":1},{"version":"89167d696a849fce5ca508032aabfe901c0868f833a8625d5a9c6e861ef935d2","impliedFormat":1},{"version":"615ba88d0128ed16bf83ef8ccbb6aff05c3ee2db1cc0f89ab50a4939bfc1943f","impliedFormat":1},{"version":"a4d551dbf8746780194d550c88f26cf937caf8d56f102969a110cfaed4b06656","impliedFormat":1},{"version":"8bd86b8e8f6a6aa6c49b71e14c4ffe1211a0e97c80f08d2c8cc98838006e4b88","impliedFormat":1},{"version":"317e63deeb21ac07f3992f5b50cdca8338f10acd4fbb7257ebf56735bf52ab00","impliedFormat":1},{"version":"4732aec92b20fb28c5fe9ad99521fb59974289ed1e45aecb282616202184064f","impliedFormat":1},{"version":"2e85db9e6fd73cfa3d7f28e0ab6b55417ea18931423bd47b409a96e4a169e8e6","impliedFormat":1},{"version":"c46e079fe54c76f95c67fb89081b3e399da2c7d109e7dca8e4b58d83e332e605","impliedFormat":1},{"version":"bf67d53d168abc1298888693338cb82854bdb2e69ef83f8a0092093c2d562107","impliedFormat":1},{"version":"88d9a77d2abc23a7d26625dd6dae5b57199a8693b85c9819355651c9d9bab90f","affectsGlobalScope":true,"impliedFormat":1},{"version":"a38efe83ff77c34e0f418a806a01ca3910c02ee7d64212a59d59bca6c2c38fa1","impliedFormat":1},{"version":"7394959e5a741b185456e1ef5d64599c36c60a323207450991e7a42e08911419","impliedFormat":1},{"version":"3fe4022ba1e738034e38ad9afacbf0f1f16b458ed516326f5bf9e4a31e9be1dc","impliedFormat":1},{"version":"a957197054b074bcdf5555d26286e8461680c7c878040d0f4e2d5509a7524944","affectsGlobalScope":true,"impliedFormat":1},{"version":"4314c7a11517e221f7296b46547dbc4df047115b182f544d072bdccffa57fc72","impliedFormat":1},{"version":"e9b97d69510658d2f4199b7d384326b7c4053b9e6645f5c19e1c2a54ede427fc","impliedFormat":1},{"version":"c2510f124c0293ab80b1777c44d80f812b75612f297b9857406468c0f4dafe29","affectsGlobalScope":true,"impliedFormat":1},{"version":"5524481e56c48ff486f42926778c0a3cce1cc85dc46683b92b1271865bcf015a","impliedFormat":1},{"version":"f478f6f5902dc144c0d6d7bdc919c5177cac4d17a8ca8653c2daf6d7dc94317f","affectsGlobalScope":true,"impliedFormat":1},{"version":"19d5f8d3930e9f99aa2c36258bf95abbe5adf7e889e6181872d1cdba7c9a7dd5","impliedFormat":1},{"version":"b200675fd112ffef97c166d0341fb33f6e29e9f27660adde7868e95c5bc98beb","impliedFormat":1},{"version":"a6bf63d17324010ca1fbf0389cab83f93389bb0b9a01dc8a346d092f65b3605f","impliedFormat":1},{"version":"e009777bef4b023a999b2e5b9a136ff2cde37dc3f77c744a02840f05b18be8ff","impliedFormat":1},{"version":"1e0d1f8b0adfa0b0330e028c7941b5a98c08b600efe7f14d2d2a00854fb2f393","impliedFormat":1},{"version":"ee1ee365d88c4c6c0c0a5a5701d66ebc27ccd0bcfcfaa482c6e2e7fe7b98edf7","affectsGlobalScope":true,"impliedFormat":1},{"version":"88bc59b32d0d5b4e5d9632ac38edea23454057e643684c3c0b94511296f2998c","affectsGlobalScope":true,"impliedFormat":1},{"version":"a0a1dda070290b92da5a50113b73ecc4dd6bcbffad66e3c86503d483eafbadcf","impliedFormat":1},{"version":"59dcad36c4549175a25998f6a8b33c1df8e18df9c12ebad1dfb25af13fd4b1ce","impliedFormat":1},{"version":"206a70e72af3e24688397b81304358526ce70d020e4c2606c4acfd1fa1e81fb2","impliedFormat":1},{"version":"3f3edb8e44e3b9df3b7ca3219ab539710b6a7f4fe16bd884d441af207e03cd57","impliedFormat":1},{"version":"528b62e4272e3ddfb50e8eed9e359dedea0a4d171c3eb8f337f4892aac37b24b","impliedFormat":1},{"version":"d71535813e39c23baa113bc4a29a0e187b87d1105ccc8c5a6ebaca38d9a9bff2","impliedFormat":1},{"version":"12d7dc6812530951eff72ffe5d849ba389531a703c443c84ae7227f2d320eedb","affectsGlobalScope":true,"impliedFormat":1},{"version":"f72bc8fe16da67e4e3268599295797b202b95e54bd215a03f97e925dd1502a36","impliedFormat":1},{"version":"b1b6ee0d012aeebe11d776a155d8979730440082797695fc8e2a5c326285678f","impliedFormat":1},{"version":"45875bcae57270aeb3ebc73a5e3fb4c7b9d91d6b045f107c1d8513c28ece71c0","impliedFormat":1},{"version":"1dc73f8854e5c4506131c4d95b3a6c24d0c80336d3758e95110f4c7b5cb16397","affectsGlobalScope":true,"impliedFormat":1},{"version":"636302a00dfd1f9fe6e8e91e4e9350c6518dcc8d51a474e4fc3a9ba07135100b","affectsGlobalScope":true,"impliedFormat":1},{"version":"3f16a7e4deafa527ed9995a772bb380eb7d3c2c0fd4ae178c5263ed18394db2c","impliedFormat":1},{"version":"933921f0bb0ec12ef45d1062a1fc0f27635318f4d294e4d99de9a5493e618ca2","impliedFormat":1},{"version":"71a0f3ad612c123b57239a7749770017ecfe6b66411488000aba83e4546fde25","impliedFormat":1},{"version":"8145e07aad6da5f23f2fcd8c8e4c5c13fb26ee986a79d03b0829b8fce152d8b2","impliedFormat":1},{"version":"e1120271ebbc9952fdc7b2dd3e145560e52e06956345e6fdf91d70ca4886464f","impliedFormat":1},{"version":"814118df420c4e38fe5ae1b9a3bafb6e9c2aa40838e528cde908381867be6466","impliedFormat":1},{"version":"e1ce1d622f1e561f6cdf246372ead3bbc07ce0342024d0e9c7caf3136f712698","impliedFormat":1},{"version":"199c8269497136f3a0f4da1d1d90ab033f899f070e0dd801946f2a241c8abba2","impliedFormat":1},{"version":"37ba7b45141a45ce6e80e66f2a96c8a5ab1bcef0fc2d0f56bb58df96ec67e972","impliedFormat":1},{"version":"125d792ec6c0c0f657d758055c494301cc5fdb327d9d9d5960b3f129aff76093","impliedFormat":1},{"version":"27e4532aaaa1665d0dd19023321e4dc12a35a741d6b8e1ca3517fcc2544e0efe","affectsGlobalScope":true,"impliedFormat":1},{"version":"2754d8221d77c7b382096651925eb476f1066b3348da4b73fe71ced7801edada","impliedFormat":1},{"version":"8c2ad42d5d1a2e8e6112625767f8794d9537f1247907378543106f7ba6c7df90","affectsGlobalScope":true,"impliedFormat":1},{"version":"f0be1b8078cd549d91f37c30c222c2a187ac1cf981d994fb476a1adc61387b14","affectsGlobalScope":true,"impliedFormat":1},{"version":"0aaed1d72199b01234152f7a60046bc947f1f37d78d182e9ae09c4289e06a592","impliedFormat":1},{"version":"98ffdf93dfdd206516971d28e3e473f417a5cfd41172e46b4ce45008f640588e","impliedFormat":1},{"version":"66ba1b2c3e3a3644a1011cd530fb444a96b1b2dfe2f5e837a002d41a1a799e60","impliedFormat":1},{"version":"7e514f5b852fdbc166b539fdd1f4e9114f29911592a5eb10a94bb3a13ccac3c4","impliedFormat":1},{"version":"7d6ff413e198d25639f9f01f16673e7df4e4bd2875a42455afd4ecc02ef156da","affectsGlobalScope":true,"impliedFormat":1},{"version":"12e8ce658dd17662d82fb0509d2057afc5e6ee30369a2e9e0957eff725b1f11d","affectsGlobalScope":true,"impliedFormat":1},{"version":"74736930d108365d7bbe740c7154706ccfb1b2a3855a897963ab3e5c07ecbf19","impliedFormat":1},{"version":"858f999b3e4a45a4e74766d43030941466460bf8768361d254234d5870480a53","impliedFormat":1},{"version":"ac5ed35e649cdd8143131964336ab9076937fa91802ec760b3ea63b59175c10a","impliedFormat":1},{"version":"63b05afa6121657f25e99e1519596b0826cda026f09372c9100dfe21417f4bd6","affectsGlobalScope":true,"impliedFormat":1},{"version":"3797dd6f4ea3dc15f356f8cdd3128bfa18122213b38a80d6c1f05d8e13cbdad8","impliedFormat":1},{"version":"ad90122e1cb599b3bc06a11710eb5489101be678f2920f2322b0ac3e195af78d","impliedFormat":1},{"version":"eac028a74dba3e0c2aa785031b7df83586beab4efce9da4903b2f3abad293d3a","impliedFormat":1},{"version":"8d22beed3e8bbf57e0adbc986f3b96011eef317fd0adadccd401bcb45d6ee57e","impliedFormat":1},{"version":"3a1fc0aae490201663c926fde22e6203a8ac6aa4c01c7f5532d2dcdde5b512f5","impliedFormat":1},{"version":"4fbae6249d3c80cc85a1d33de46f350678f8af87b9566abce87e6e22960271b7","impliedFormat":1},{"version":"d36c6f1f19a6c298a6e10f87d9b1f2d05e528251bbe351f95b1b805b42c2d627","impliedFormat":1},{"version":"a7f590406204026bf49d737edb9d605bb181d0675e5894a6b80714bbc525f3df","impliedFormat":1},{"version":"533039607e507410c858c1fa607d473deacb25c8bf0c3f1bd74873af5210e9a0","impliedFormat":1},{"version":"b09561e71ae9feab2e4d2b06ceb7b89de7fad8d6e3dc556c33021f20b0fb88c4","impliedFormat":1},{"version":"dd79d768006bfd8dd46cf60f7470dca0c8fa25a56ac8778e40bd46f873bd5687","impliedFormat":1},{"version":"4daacd053dd57d50a8cdf110f5bc9bb18df43cd9bcc784a2a6979884e5f313de","impliedFormat":1},{"version":"d103fff68cd233722eea9e4e6adfb50c0c36cc4a2539c50601b0464e33e4f702","impliedFormat":1},{"version":"3c6d8041b0c8db6f74f1fd9816cd14104bcd9b7899b38653eb082e3bdcfe64d7","impliedFormat":1},{"version":"4207e6f2556e3e9f7daa5d1dd1fdaa294f7d766ebea653846518af48a41dd8e0","impliedFormat":1},{"version":"c94b3332d328b45216078155ba5228b4b4f500d6282ac1def812f70f0306ed1c","impliedFormat":1},{"version":"43497bdd2d9b53afad7eed81fb5656a36c3a6c735971c1eed576d18d3e1b8345","impliedFormat":1},{"version":"5db2d64cfcfbc8df01eda87ce5937cb8af952f8ba8bbc8fd2a8ef10783614ca7","impliedFormat":1},{"version":"b13319e9b7e8a9172330a364416d483c98f3672606695b40af167754c91fa4ec","impliedFormat":1},{"version":"7f8a5e8fc773c089c8ca1b27a6fea3b4b1abc8e80ca0dd5c17086bbed1df6eaa","impliedFormat":1},{"version":"0d54e6e53636877755ac3e2fab3e03e2843c8ca7d5f6f8a18bbf5702d3771323","impliedFormat":1},{"version":"124b96661046ec3f63b7590dc13579d4f69df5bb42fa6d3e257c437835a68b4d","impliedFormat":1},{"version":"46ae33e47b6f5ab42883be3ef6d989733080ac440bfd08041841750bbffe26e0","impliedFormat":1},{"version":"724775a12f87fc7005c3805c77265374a28fb3bc93c394a96e2b4ffee9dde65d","impliedFormat":1},{"version":"431f29f17261cff4937375ff478f8f0d992059c0a2b266cc64030fb0e736ce74","impliedFormat":1},{"version":"20064a8528651a0718e3a486f09a0fd9f39aaca3286aea63ddeb89a4428eab2b","impliedFormat":1},{"version":"743da6529a5777d7b68d0c6c2b006800d66e078e3b8391832121981d61cd0abc","impliedFormat":1},{"version":"f87c199c9f52878c8a2f418af250ccfc80f2419d0bd9b8aebf4d4822595d654f","impliedFormat":1},{"version":"57397be192782bd8bedf04faa9eea2b59de3e0cfa1d69367f621065e7abd253b","impliedFormat":1},{"version":"df9e6f89f923a5e8acf9ce879ec70b4b2d8d744c3fb8a54993396b19660ac42a","impliedFormat":1},{"version":"175628176d1c2430092d82b06895e072176d92d6627b661c8ea85bee65232f6e","impliedFormat":1},{"version":"21625e9b1e7687f847a48347d9b77ce02b9631e8f14990cffb7689236e95f2bb","impliedFormat":1},{"version":"483fad2b4ebaabd01e983d596e2bb883121165660060f498f7f056fecd6fb56a","impliedFormat":1},{"version":"6a089039922bf00f81957eafd1da251adb0201a21dcb8124bcfed14be0e5b37d","impliedFormat":1},{"version":"6cd1c25b356e9f7100ca69219522a21768ae3ea9a0273a3cc8c4af0cbd0a3404","impliedFormat":1},{"version":"201497a1cbe0d7c5145acd9bf1b663737f1c3a03d4ecffd2d7e15da74da4aaf1","impliedFormat":1},{"version":"66e92a7b3d38c8fa4d007b734be3cdcd4ded6292753a0c86976ac92ae2551926","impliedFormat":1},{"version":"a8e88f5e01065a9ab3c99ff5e35a669fdb7ae878a03b53895af35e1130326c15","impliedFormat":1},{"version":"05a8dfa81435f82b89ecbcb8b0e81eb696fac0a3c3f657a2375a4630d4f94115","impliedFormat":1},{"version":"5773e4f6ac407d1eff8ef11ccaa17e4340a7da6b96b2e346821ebd5fff9f6e30","impliedFormat":1},{"version":"c736dd6013cac2c57dffb183f9064ddd6723be3dfc0da1845c9e8a9921fc53bb","impliedFormat":1},{"version":"7b43949c0c0a169c6e44dcdf5b146f5115b98fa9d1054e8a7b420d28f2e6358f","impliedFormat":1},{"version":"b46549d078955775366586a31e75028e24ad1f3c4bc1e75ad51447c717151c68","impliedFormat":1},{"version":"34dd068c2a955f4272db0f9fdafb6b0871db4ec8f1f044dfc5c956065902fe1c","impliedFormat":1},{"version":"e5854625da370345ba85c29208ae67c2ae17a8dbf49f24c8ed880c9af2fe95b2","impliedFormat":1},{"version":"cf1f7b8b712d5db28e180d907b3dd2ba7949efcfec81ec30feb229eee644bda4","impliedFormat":1},{"version":"2423fa71d467235a0abffb4169e4650714d37461a8b51dc4e523169e6caac9b8","impliedFormat":1},{"version":"4de5d28c3bc76943453df1a00435eb6f81d0b61aa08ff34ae9c64dd8e0800544","impliedFormat":1},{"version":"e9ab0cb47842267615bfc3f080b735a0b29bf04f6d5dfa2b3b05b15c6f6dfbc5","impliedFormat":1},{"version":"e53462960e9799ff89f63e847d3a338bdadcc41fc98a816b9aaf32e82cb0071a","impliedFormat":1},{"version":"9593de9c14310da95e677e83110b37f1407878352f9ebe1345f97fc69e4b627c","impliedFormat":1},{"version":"e009f9f511db1a215577f241b2dc6d3f9418f9bc1686b6950a1d3f1b433a37ff","impliedFormat":1},{"version":"caa48f3b98f9737d51fabce5ce2d126de47d8f9dffeb7ad17cd500f7fd5112e0","impliedFormat":1},{"version":"64d15723ce818bb7074679f5e8d4d19a6e753223f5965fd9f1a9a1f029f802f7","impliedFormat":1},{"version":"2900496cc3034767cd31dd8e628e046bc3e1e5f199afe7323ece090e8872cfa7","impliedFormat":1},{"version":"ba74ef369486b613146fa4a3bccb959f3e64cdc6a43f05cc7010338ba0eab9f7","impliedFormat":1},{"version":"58ce0e6b87ffb9f58608e2a1adae45487e07074fe2a591feb6ad660416e26b2f","impliedFormat":1},{"version":"c4f885600b6f398223fab2c97165befb768a4a6348008b1e995906d070992d15","impliedFormat":1},{"version":"6d2089f3928a72795c3648b3a296047cb566cd2dae161db50434faf12e0b2843","impliedFormat":1},{"version":"5cb00927cbb410110dde3fb0fda5f1b093f53af27a8e6869233315c635d78708","impliedFormat":1},{"version":"c477c9c6003e659d5aad681acd70694176d4f88fc16cc4c5bcfa5b8dcc01874b","impliedFormat":1},{"version":"ca2ebe3f3791275d3287eed417660b515eb4d171f0b7badcfa95f0f709b149f7","impliedFormat":1},{"version":"8605b33c2b65285339bc24989f456eb818eab5a117f1a92f94d77951ea0e1b36","impliedFormat":1},{"version":"e2a4983a141f4185996e1ab3230cb24754c786d68434f2e7659276c325f3c46c","impliedFormat":1},{"version":"b2216c0b4c7f32e7e9bba74d0223fc9ad3bec50b71663701d60578cecc323fb5","impliedFormat":1},{"version":"1cbbd9272af325d7189d845c75bbdb6d467ce1691afe12bcb9964e4bd1270e66","impliedFormat":1},{"version":"86eb11b1e540fe07b2ebfc9cca24c35b005f0d81edf7701eaf426db1f5702a07","impliedFormat":1},{"version":"ee3457d827475b9e64ea793f49a83fffbb4b8fefe534b8f0a340b0e47d786e76","impliedFormat":1},{"version":"67cbde477deac96c2b92ccb42d9cf21f2a7417f8df9330733643cc101aa1bca5","impliedFormat":1},{"version":"2cb440791f9d52fa2222c92654d42f510bf3f7d2f47727bf268f229feced15ba","impliedFormat":1},{"version":"5bb4355324ea86daf55ee8b0a4d0afdef1b8adadc950aab1324c49a3acd6d74e","impliedFormat":1},{"version":"64e07eac6076ccb2880461d483bae870604062746415393bfbfae3db162e460a","impliedFormat":1},{"version":"5b6707397f71e3e1c445a75a06abf882872d347c4530eef26c178215de1e6043","impliedFormat":1},{"version":"c74d9594bda9fe32ab2a99010db232d712f09686bbee66f2026bc17401fe7b7e","impliedFormat":1},{"version":"15bbb824c277395f8b91836a5e17fedc86f3bb17df19dcdc5173930fd50cc83e","impliedFormat":1},{"version":"4de5d28c3bc76943453df1a00435eb6f81d0b61aa08ff34ae9c64dd8e0800544","impliedFormat":1},{"version":"1c94de96416c02405da00d8f7bde9d196064c3ce1464f0c4df1966202196b558","impliedFormat":1},{"version":"406cc85801b49efd5f75c84cc557e2bba9155c7f88c758c3fadd4e844ad6b19e","impliedFormat":1},{"version":"6d235f62eb41ac4010a0dab8ba186c20dec8565f42273a34f0fa3fc3ca9d0dbb","impliedFormat":1},{"version":"f7663954884610aeb38c78ffd22525749fab19ab5e86e4a53df664180efd1ff5","impliedFormat":1},{"version":"4ac0045aa4bc48b5f709da38c944d4fec2368eda6b67e4dd224147f3471b7eaf","impliedFormat":1},{"version":"e998acd4765ee7f773680312968618498994f00963f4079301766a6273429769","impliedFormat":1},{"version":"71390fe0b867a2161bd39c63f7d35c128933efbbae63eae91605fe4ae6895faf","impliedFormat":1},{"version":"3e717eef40648a7d8895219063b1e5cb5bcc404bc1d41a22b91f3140b83bce1d","impliedFormat":1},{"version":"9b61c06ab1e365e5b32f50a56c0f3bb2491329bb3cd2a46e8caa30edcf0281cc","impliedFormat":1},{"version":"8f91df3614625daa000bffe84a5c1939b4da0254db9d7c62764f916ebb93dcdc","impliedFormat":1},{"version":"ee745db646de4c5cf019e495ff5d800ed6f4ee9d9b3aaa7b2c5ca836928bc80e","impliedFormat":1},{"version":"d8d808ab0c5c550fb715641e1f5813dededa9b657e7ed3c3a6665ce7f629273d","impliedFormat":1},{"version":"059a7dfc70b0e875ef87a961d1e9b69917a32a6eea1c3950a5aad8c62d8274aa","impliedFormat":1},{"version":"cf575b64fadf5f646c0f715730c490f317f856f5b3bbe06493638576bad711d9","impliedFormat":1},{"version":"86e8053735c07114cc6be9f70bbc1d53820fbc76c6b08963bbc9a11070a9e354","impliedFormat":1},{"version":"6306621db4fbb1c1e79883599912c32da2c5974402531b47a2cf2c19ce61200e","impliedFormat":1},{"version":"db1c864a7ab8f401c793a040d3f708cc9a5e5a7d2e6a7a0783b8f256acfb322b","impliedFormat":1},{"version":"f263db23ce0b198ab373032126d83eb6bcd9a70c1f08048e7770dac32297d9b5","impliedFormat":1},{"version":"3d51b78be622aa3f4afa5cbe7ca35dec64406c1436aaee61cd4a24b9060b7f25","impliedFormat":1},{"version":"aa8f659712fd02d08bdf17d3a93865d33bd1ee3b5bcf2120b2aa5e9374a74157","impliedFormat":1},{"version":"5a06765319ef887a78dd42ca5837e2e46723525b0eaa53dd31b36ba9b9d33b56","impliedFormat":1},{"version":"27bf29df603ae9c123ffd3d3cfd3b047b1fa9898bf04e6ab3b05db95beebb017","impliedFormat":1},{"version":"5f019b4b2cd2dbf4cd24288d9858ef819a81f89c49663b6d13d0f4d1b8ea6b22","impliedFormat":1},{"version":"ff3174855c0939abcec4c17b4e541f7953edee00b6219697a1032f2c7f1dbb2a","impliedFormat":1},{"version":"79eec21ed8d68daad880d96f5865a9c5247d01170ad8ff7f350a441216c12018","impliedFormat":1},{"version":"9d1c3fe1639a48bfd9b086b8ae333071f7da60759344916600b979b7ed6ffaa6","impliedFormat":1},{"version":"8b3d89d08a132d7a2549ac0a972af3773f10902908a96590b3fe702c325a80ec","impliedFormat":1},{"version":"fa294d757c39c4d65e52e4d17084ee63b52b04e0864bc04d4b16adc243b9f542","impliedFormat":1},{"version":"12c937d1a8441bb44d7218e11a9cfb1c6f3df435b97e91bbdef447cd0353ce8f","impliedFormat":1},{"version":"49cfd2c983594c18fe36f64c82d5e1282fd5d42168e925937345ef927b07f073","impliedFormat":1},{"version":"4de5d28c3bc76943453df1a00435eb6f81d0b61aa08ff34ae9c64dd8e0800544","impliedFormat":1},{"version":"07ea97f8e11cedfb35f22c5cab2f7aacd8721df7a9052fb577f9ba400932933b","impliedFormat":1},{"version":"66ab54a2a098a1f22918bd47dc7af1d1a8e8428aa9c3cb5ef5ed0fef45a13fa4","impliedFormat":1},{"version":"ff3f1d258bd14ca6bbf7c7158580b486d199e317fc4c433f98f13b31e6bb5723","impliedFormat":1},{"version":"a3f1cac717a25f5b8b6df9deef8fc8d0a0726390fdaa83aed55be430cd532ebf","impliedFormat":1},{"version":"f1a1edb271da27e2d8925a68db1eb8b16d8190037eb44a324b826e54f97e315f","impliedFormat":1},{"version":"1553d16fb752521327f101465a3844fe73684503fdd10bed79bd886c6d72a1bc","impliedFormat":1},{"version":"f3c511e1d8b463dc37eaf777b0a620cbd4dd2fe448a16413dc300a831c397b91","impliedFormat":1},{"version":"bf22ee38d4d989e1c72307ab701557022e074e66940cf3d03efa9beb72224723","impliedFormat":1},{"version":"8cfc217946d7341705924aef14d4bf0aa4b83e3530669932672e2070e788b49c","impliedFormat":1},{"version":"271119c7cbd09036fd8bd555144ec0ea54d43b59bcb3d8733995c8ef94cb620b","impliedFormat":1},{"version":"5a51eff6f27604597e929b13ee67a39267df8f44bbd6a634417ed561a2fa05d6","impliedFormat":1},{"version":"1f93b377bb06ed9de4dc4eb664878edb8dcac61822f6e7633ca99a3d4a1d85da","impliedFormat":1},{"version":"53e77c7bf8f076340edde20bf00088543230ba19c198346112af35140a0cfac5","impliedFormat":1},{"version":"cec6a5e638d005c00dd6b1eaafe6179e835022f8438ff210ddb3fe0ae76f4bf9","impliedFormat":1},{"version":"c264c5bb2f6ec6cea1f9b159b841fc8f6f6a87eb279fef6c471b127c41001034","impliedFormat":1},{"version":"ff42cc408214648895c1de8ada2143edc3379b5cbb7667d5add8b0b3630c9634","impliedFormat":1},{"version":"c9018ca6314539bf92981ab4f6bc045d7caaff9f798ce7e89d60bb1bb70f579c","impliedFormat":1},{"version":"d74c5b76c1c964a2e80a54f759de4b35003b7f5969fb9f6958bd263dcc86d288","impliedFormat":1},{"version":"b83a3738f76980505205e6c88ca03823d01b1aa48b3700e8ba69f47d72ab8d0f","impliedFormat":1},{"version":"01b9f216ada543f5c9a37fbc24d80a0113bda8c7c2c057d0d1414cde801e5f9d","impliedFormat":1},{"version":"f1e9397225a760524141dc52b1ca670084bde5272e56db1bd0ad8c8bea8c1c30","impliedFormat":1},{"version":"08c43afe12ba92c1482fc4727aab5f788a83fd49339eb0b43ad01ed2b5ad6066","impliedFormat":1},{"version":"6066b918eb4475bfcce362999f7199ce5df84cea78bd55ed338da57c73043d45","impliedFormat":1},{"version":"c67beadff16a8139f87dc9c07581500d88abd21e8436c9e9bf25f2ee39c5b1af","impliedFormat":1},{"version":"e39514fc08fdedd95766643609b0ede54386156196d79a2d9d49247fb4406dcd","impliedFormat":1},{"version":"e4a4e40e8bc24425e03de8f002c62448dbaefe284278c0a1d93af2bfd2b528c2","impliedFormat":1},{"version":"808f19d665f7c7ed31a3f35c7756ca58130be62de9a7fad9b5f8b4b957ce16fc","impliedFormat":1},{"version":"4de5d28c3bc76943453df1a00435eb6f81d0b61aa08ff34ae9c64dd8e0800544","impliedFormat":1},{"version":"c67beadff16a8139f87dc9c07581500d88abd21e8436c9e9bf25f2ee39c5b1af","impliedFormat":1},{"version":"83995c7fa683c849e9e4d2a33c6e2421e10e31277bacec7769a4c2cabdebec02","impliedFormat":1},{"version":"ac8582e453158a1e4cccfb683af8850b9d2a0420e7f6f9a260ab268fc715ab0d","impliedFormat":1},{"version":"c80aa3ff0661e065d700a72d8924dcec32bf30eb8f184c962da43f01a5edeb6f","impliedFormat":1},{"version":"837f5c12e3e94ee97aca37aa2a50ede521e5887fb7fa89330f5625b70597e116","impliedFormat":1},{"version":"33e2d7a5bf6ceb9159e3e919b39497d72d6437cede9a1e8f0db6553bb5b73cf9","impliedFormat":1},{"version":"eb34b5818c9f5a31e020a8a5a7ca3300249644466ef71adf74e9e96022b8b810","impliedFormat":1},{"version":"cdec09a633b816046d9496a59345ad81f5f97c642baf4fe1611554aa3fbf4a41","impliedFormat":1},{"version":"5b933c1b71bff2aa417038dabb527b8318d9ef6136f7bd612046e66a062f5dbf","impliedFormat":1},{"version":"b94a350c0e4d7d40b81c5873b42ae0e3629b0c45abf2a1eeb1a3c88f60a26e9a","impliedFormat":1},{"version":"231f407c0f697534facae9ca5d976f3432da43d5b68f0948b55063ca53831e7c","impliedFormat":1},{"version":"188857be1eebad5f4021f5f771f248cf04495e27ad467aa1cf9624e35346e647","impliedFormat":1},{"version":"d0a20f432f1f10dc5dbb04ae3bee7253f5c7cee5865a262f9aac007b84902276","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"c9c212346f1d2a5d0e3aa81f7591e0448f77541dd7118c0d339dd8c0b371599b","impliedFormat":1},{"version":"7fb49dc334a15760a18028b68fdd1e5e086add56d6998dc24fd6a5aca740b2e5","impliedFormat":1},{"version":"2d1cb20d43a9fa3599bf9b325be22fed349289b06508356ab993eb8d92dc5156","impliedFormat":1},{"version":"e53462960e9799ff89f63e847d3a338bdadcc41fc98a816b9aaf32e82cb0071a","impliedFormat":1},{"version":"9593de9c14310da95e677e83110b37f1407878352f9ebe1345f97fc69e4b627c","impliedFormat":1},{"version":"e009f9f511db1a215577f241b2dc6d3f9418f9bc1686b6950a1d3f1b433a37ff","impliedFormat":1},{"version":"caa48f3b98f9737d51fabce5ce2d126de47d8f9dffeb7ad17cd500f7fd5112e0","impliedFormat":1},{"version":"64d15723ce818bb7074679f5e8d4d19a6e753223f5965fd9f1a9a1f029f802f7","impliedFormat":1},{"version":"2900496cc3034767cd31dd8e628e046bc3e1e5f199afe7323ece090e8872cfa7","impliedFormat":1},{"version":"ba74ef369486b613146fa4a3bccb959f3e64cdc6a43f05cc7010338ba0eab9f7","impliedFormat":1},{"version":"58ce0e6b87ffb9f58608e2a1adae45487e07074fe2a591feb6ad660416e26b2f","impliedFormat":1},{"version":"c4f885600b6f398223fab2c97165befb768a4a6348008b1e995906d070992d15","impliedFormat":1},{"version":"6d2089f3928a72795c3648b3a296047cb566cd2dae161db50434faf12e0b2843","impliedFormat":1},{"version":"5cb00927cbb410110dde3fb0fda5f1b093f53af27a8e6869233315c635d78708","impliedFormat":1},{"version":"83995c7fa683c849e9e4d2a33c6e2421e10e31277bacec7769a4c2cabdebec02","impliedFormat":1},{"version":"ac8582e453158a1e4cccfb683af8850b9d2a0420e7f6f9a260ab268fc715ab0d","impliedFormat":1},{"version":"c80aa3ff0661e065d700a72d8924dcec32bf30eb8f184c962da43f01a5edeb6f","impliedFormat":1},{"version":"33e2d7a5bf6ceb9159e3e919b39497d72d6437cede9a1e8f0db6553bb5b73cf9","impliedFormat":1},{"version":"eb34b5818c9f5a31e020a8a5a7ca3300249644466ef71adf74e9e96022b8b810","impliedFormat":1},{"version":"cdec09a633b816046d9496a59345ad81f5f97c642baf4fe1611554aa3fbf4a41","impliedFormat":1},{"version":"5b933c1b71bff2aa417038dabb527b8318d9ef6136f7bd612046e66a062f5dbf","impliedFormat":1},{"version":"b94a350c0e4d7d40b81c5873b42ae0e3629b0c45abf2a1eeb1a3c88f60a26e9a","impliedFormat":1},{"version":"231f407c0f697534facae9ca5d976f3432da43d5b68f0948b55063ca53831e7c","impliedFormat":1},{"version":"188857be1eebad5f4021f5f771f248cf04495e27ad467aa1cf9624e35346e647","impliedFormat":1},{"version":"d0a20f432f1f10dc5dbb04ae3bee7253f5c7cee5865a262f9aac007b84902276","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"b1bcb9d6aeaeb73041c906ec1ec25937f0998c35d2e89562e839076e1b7364ab","impliedFormat":1},{"version":"9b393353bbf233fd5677eef899b7fb0df9097ce98d1dcf6f2ff03331de462734","impliedFormat":1},{"version":"4e03465826d61ddd2a4c727b4799f1c6852616b4de8e2c012f570d73d6a46b9e","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"78ef0198c323d0f7b16f993ada3459f0e7e20567e7f56fe0c5ee78f31cb0840c","impliedFormat":1},{"version":"01dea450d742aa55ce9b8ab8877bbda8eb73bf88609e440cc34f6f59f35080db","impliedFormat":1},{"version":"5ec614ed82e045de15417a47e2568be5310d43d4764ee43d295ea38caafbfd17","impliedFormat":1},{"version":"b788ef070e70003842cbd03c3e04f87d46b67a47b71e9e7d8713fd8c58c5f5ec","impliedFormat":1},{"version":"583d365dc19f813f1e2767771e844c7c4ea9ab1a01e85e0119f2e083488379c2","impliedFormat":1},{"version":"b82fc3869c625b828dd3feac4b5ebf335ed007d586dc16176602db73bc4e7c65","impliedFormat":1},{"version":"05e30605274c26f405c411eebed776fa2102418c05beec885e5c9bd0fa716f32","impliedFormat":1},{"version":"58c7f7820dc027a539b0437be7e1f8bdf663f91fbc9e861d80bb9368a38d4a94","impliedFormat":1},{"version":"d67d6b779d0dece9450d7a4170d3ee58ea7fcae0af2ab5e1d0ad711474b4f7f5","impliedFormat":1},{"version":"1066c11177d085898185548e1b38ed15fcea50061508f7c313ab8bec35d46b95","impliedFormat":1},{"version":"bbc49fd9dc6ee162ba3d270c834398e0c1d44e657ac4edfa55ac837902b7e0da","impliedFormat":1},{"version":"6993f360de4984b6743764fad3b88246d5dc6cfa45567783fc23833ad4e50c13","impliedFormat":1},{"version":"f11eb1fb4e569b293a7cae9e7cdae57e13efc12b0e4510e927868c93ec055e82","impliedFormat":1},{"version":"715682cddbefe50e27e5e7896acf4af0ffc48f9e18f64b0a0c2f8041e3ea869b","impliedFormat":1},{"version":"6d2f5a67bfe2034aa77b38f10977a57e762fd64e53c14372bcc5f1d3175ca322","impliedFormat":1},{"version":"4ff4add7b8cf26df217f2c883292778205847aefb0fd2aee64f5a229d0ffd399","impliedFormat":1},{"version":"33859aa36b264dd91bef77c279a5a0d259c6b63684d0c6ad538e515c69a489ec","impliedFormat":1},{"version":"33fa69f400b34c83e541dd5f4474f1c6fb2788614a1790c6c7b346b5c7eaa7dd","impliedFormat":1},{"version":"be213d7cbc3e5982b22df412cf223c2ac9d841c75014eae4c263761cd9d5e4c0","impliedFormat":1},{"version":"66451f9540fdf68a5fd93898257ccd7428cf7e49029f2e71b8ce70c8d927b87a","impliedFormat":1},{"version":"8a051690018330af516fd9ea42b460d603f0839f44d3946ebb4b551fe3bc7703","impliedFormat":1},{"version":"301fb04ef91ae1340bec1ebc3acdd223861c887a4a1127303d8eef7638b2d893","impliedFormat":1},{"version":"06236dfec90a14b0c3db8249831069ea3f90b004d73d496a559a4466e5a344a4","impliedFormat":1},{"version":"fc26991e51514bfc82e0f20c25132268b1d41e8928552dbaed7cc6f3d08fc3ac","impliedFormat":1},{"version":"5d82bb58dec5014c02aaeb3da465d34f4b7d5c724afea07559e3dfca6d8da5bc","impliedFormat":1},{"version":"44448f58f4d731dc28a02b5987ab6f20b9f77ad407dcf57b68c853fe52195cd7","impliedFormat":1},{"version":"b2818e8d05d6e6ad0f1899abf90a70309240a15153ea4b8d5e0c151e117b7338","impliedFormat":1},{"version":"1c708c15bb96473ce8ec2a946bd024ecded341169a0b84846931f979172244ba","impliedFormat":1},{"version":"ed0f5e1f45dc7c3f40356e0a855e8594aa57c125a5d8dfeef118e0a3024f98ff","impliedFormat":1},{"version":"dc187f457333356ddc1ab8ec7833cd836f85e0bbcade61290dc55116244867cb","impliedFormat":1},{"version":"25525e173de74143042e824eaa786fa18c6b19e9dafb64da71a5faacc5bd2a5c","impliedFormat":1},{"version":"7a3d649f2de01db4b316cf4a0ce5d96832ee83641f1dc84d3e9981accf29c3a1","impliedFormat":1},{"version":"26e4260ee185d4af23484d8c11ef422807fb8f51d33aa68d83fab72eb568f228","impliedFormat":1},{"version":"c4d52d78e3fb4f66735d81663e351cf56037270ed7d00a9b787e35c1fc7183ce","impliedFormat":1},{"version":"864a5505d0e9db2e1837dce8d8aae8b7eeaa5450754d8a1967bf2843124cc262","impliedFormat":1},{"version":"2d045f00292ac7a14ead30d1f83269f1f0ad3e75d1f8e5a245ab87159523cf98","impliedFormat":1},{"version":"54bcb32ab0c7c72b61becd622499a0ae1c309af381801a30878667e21cba85bb","impliedFormat":1},{"version":"20666518864143f162a9a43249db66ca1d142e445e2d363d5650a524a399b992","impliedFormat":1},{"version":"28439c9ebd31185ae3353dd8524115eaf595375cd94ca157eefcf1280920436a","impliedFormat":1},{"version":"84344d56f84577d4ac1d0d59749bb2fde14c0fb460d0bfb04e57c023748c48a6","impliedFormat":1},{"version":"7700b2fe36a1f602829b7d6fa21be7aa8ef58b4e765ba26510c098de83f0835b","impliedFormat":1},{"version":"66738976a7aa2d5fb2770a1b689f8bc643af958f836b7bc08e412d4092de3ab9","impliedFormat":1},{"version":"35a0eac48984d20f6da39947cf81cd71e0818feefc03dcb28b4ac7b87a636cfd","impliedFormat":1},{"version":"f6c226d8222108b3485eb0745e8b0ee48b0b901952660db20e983741e8852654","impliedFormat":1},{"version":"93c3b758c4dc64ea499c9416b1ed0e69725133644b299b86c5435e375d823c75","impliedFormat":1},{"version":"4e85f443714cff4858fdaffed31052492fdd03ff7883b22ed938fc0e34b48093","impliedFormat":1},{"version":"0146912d3cad82e53f779a0b7663f181824bba60e32715adb0e9bd02c560b8c6","impliedFormat":1},{"version":"70754650d1eba1fc96a4ed9bbbc8458b341b41063fe79f8fa828db7059696712","impliedFormat":1},{"version":"220783c7ca903c6ce296b210fae5d7e5c5cc1942c5a469b23d537f0fbd37eb18","impliedFormat":1},{"version":"0974c67cf3e2d539d0046c84a5e816e235b81c8516b242ece2ed1bdbb5dbd3d6","impliedFormat":1},{"version":"b4186237e7787a397b6c5ae64e155e70ac2a43fdd13ff24dfb6c1e3d2f930570","impliedFormat":1},{"version":"2647784fffa95a08af418c179b7b75cf1d20c3d32ed71418f0a13259bf505c54","impliedFormat":1},{"version":"0480102d1a385b96c05316b10de45c3958512bb9e834dbecbbde9cc9c0b22db3","impliedFormat":1},{"version":"eea44cfed69c9b38cc6366bd149a5cfa186776ca2a9fb87a3746e33b7e4f5e74","impliedFormat":1},{"version":"7f375e5ef1deb2c2357cba319b51a8872063d093cab750675ac2eb1cef77bee9","impliedFormat":1},{"version":"b7f06aec971823244f909996a30ef2bbeae69a31c40b0b208d0dfd86a8c16d4f","impliedFormat":1},{"version":"0421510c9570dfae34b3911e1691f606811818df00354df7abd028cee454979f","impliedFormat":1},{"version":"1517236728263863a79500653cc15ceb286f048907b3dba3141a482ca6946bd7","impliedFormat":1},{"version":"7c7b418e467a88a714b4c6dac321923b933f82875f063f48abf952021a2c2df1","impliedFormat":1},{"version":"33120063a7e106818ce109be9238569edca74d4e8530f853bd30d298d1375fd8","impliedFormat":1},{"version":"7286f8a70b412feb6eb225f8c270fa77f6aa3e69a22dae6406fb0d4c5769052e","impliedFormat":1},{"version":"cb7d1159c7b2b404af20a96a4a3a4ec52df7bbd6575bd59bbc969fee3a194628","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"8443829ee86005187f7eb6fbe3946db7f4be1c97eff450b65ed4f12b958be610","impliedFormat":1},{"version":"83e0fb89ed33b8d2f2a5bb69f56ed46f534c9157f82fb73924418c47b1677ea4","impliedFormat":1},{"version":"451ad832907edee7669188e7fa4e0c1ee8283531156fc191a2909e959417793a","impliedFormat":1},{"version":"7010c4d2181ceacfaaff77ae474bb0a73c44883cd385b5654aba10e9b3d9c0d4","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"5cb00927cbb410110dde3fb0fda5f1b093f53af27a8e6869233315c635d78708","impliedFormat":1},{"version":"fed310cc0120d84237465237fee88257279a9b9300cb53a81de30f8929129820","impliedFormat":1},{"version":"b63bae9b21ed5aaf7cc1e0c7368c9a6dcef74079bb94241e822d0519edbb352b","impliedFormat":1},{"version":"ec91e5d57d18e1214abec9e77a62de91f846821a287ccde588bbde0c9191ef95","impliedFormat":1},{"version":"0a0941b26ecc3a581900339fe8e27dad452af6e6ed6fafe5121195146619fd6c","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"86e85c50cda432f666993b3ddd3f5ae86879e72706c4a8dadaaad00a2cd86da7","impliedFormat":1},{"version":"cf0711d84f945351cec5a362f5b3b77d4d2580e1e6ea356cae8b3cf594d43ac8","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"c49f2a791ea76975972baf06a71f6fa34e6adf74bbe8282e28e55ddb9f8903fa","impliedFormat":1},{"version":"104c67f0da1bdf0d94865419247e20eded83ce7f9911a1aa75fc675c077ca66e","impliedFormat":1},{"version":"a2b4cc3010e06ae28e250d1d6401fbf1d179daffc9ae653a33d1721e52fba757","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"eee5ccaad9b34d9815ebc9ed75631a8e8abbf3f0c685ee5af502388e6772dcf8","impliedFormat":1},{"version":"54f1102b3cefc233f851dd044fe0ec4b1ccf8aa73451c88f8b80d9b890e99635","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"d20e61890e4955c0cbe4baf77b5b0680692daf91759d541f38562a4c3a0d32d2","impliedFormat":1},{"version":"c6274b046ab2d3a5afb74155093c37431f8d9b91da4b816ef40f0c8e6195aeef","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"bd0ec2845d7857116f0945896c976ed3ea560e765eb814818451a26b2031b1a4","impliedFormat":1},{"version":"346c4abae1e0635861e9a78a93a0abefac83f611a1ef552d8b909c6d3c6abc30","impliedFormat":1},{"version":"20697a37f6566696930ed98cbe4e1faf741bcda5d352a1d42db92421cfadae2e","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"ec86649677d7ba4d41943047a1cdbb029ea50749d0f67cc36b824b2769ac3801","impliedFormat":1},{"version":"60a18df24bfc2a55e9412a7b58497757de398f811019008f94f9e98cbf1feeb4","impliedFormat":1},{"version":"0d1dc16f555e4ef480ac563fe9a41add043aa5ce050026e39d7032ee85ad242a","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"ba5675f82d2a5429a86089ccbbc553f160479dc468e87c693d909c54ffb335a0","impliedFormat":1},{"version":"7fb5e675ef4b433dbcd03f4af6fd907f6e0efdddb4f90c9958a9781217547060","impliedFormat":1},{"version":"c54ac39ccccc7a6dc61ff9b65207345547f44e7cc87a1a0d3d9a691e7d8417d4","impliedFormat":1},{"version":"c76f233c97e3880ce45b5815a2702c3eb797faaa1cc9ddb327facdb33d5ce960","impliedFormat":1},{"version":"b6579417b4231f0312e715234cc604aa791f237aa4e04b430449181806df1b34","impliedFormat":1},{"version":"1bfe28773d24fe646383a20ce9673d3041c6ba055259810275c72b043b8aea54","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"7591de3cce30c3f5cbd1a23434c624c7a85460b3e200d7948b11b95266ebf45c","impliedFormat":1},{"version":"18cdc03ac7a700074148ec15261c1c549edcc71e508e20a9d48174671c403ac2","impliedFormat":1},{"version":"669f25dc09eef6a618fd4f3dde72e6f4145cb782379164a622014274306357ec","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"e9fa91a4a30d74455ddc82abc2081ce4e7a8631a27336da25309071296117a85","impliedFormat":1},{"version":"f1fad0285a6b0fd008727c43937f508b2a8bbbe31a03801fac7a668da92e0fc9","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"e858abcfb13e2de2b7f51a03b1ed471aa98e29f564c0bfaf94f5085bcd6c5486","impliedFormat":1},{"version":"aa1d36eefffe4293cd9a7f77475a229de9e679fd4dab35c53737689615413f00","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"a6334d1b1898f3eeaeca520e4a64623d7452249092d0a9b1c6817155d6a2f521","impliedFormat":1},{"version":"e083f5318bff20be11a5427fcd1e53f738b8d473476e53d0cebfb615cc96cdad","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"7f6e499db7e0f65aa9b32e1080b7ac7a7a27bc3d4b5a89c15b8c1fedd1db9f17","impliedFormat":1},{"version":"446b6f8260e951ca247dc5444b30898211f775f4b24771f537e4c04c80c05586","impliedFormat":1},{"version":"5b918ab2d83707b6a83bd6653bdb1f125b6ea572c1c321505f9fc46d439a1610","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"758a5d99e9a94bfa1a599fa17c0417ba2f8562d9a72ae6e4c407ad8928134752","impliedFormat":1},{"version":"bff0c0d1325ed1155d5a6a85492cb005f20217974007c33dd6e126962062274a","impliedFormat":1},{"version":"b390ca7159e608d30b54b570a0fd001444a449fbd4f435e62d812e99da4a6276","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"44b50ffdbc1fbc61e2a3043a2055bc13314912552252f543d039ab269e29980a","impliedFormat":1},{"version":"4345c4a8e9ae589d86fc22b3186ba06e45804cd1483c8cad2be7d2745d1affce","impliedFormat":1},{"version":"0b245818cd92fe42dd4f92a7fe1a3300405fa5b01acb37f4f0a4e1b1babfb550","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"323aa4cde842355657626b90feff512a0dd30b7e4e177df51dd49274b8a60ace","impliedFormat":1},{"version":"0226ef283c08c4ad3882c35b9499686b7f290eef78dcd3be838fcb30bb3181a4","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"7e409aea716df22aa31db2f81937a387dd5f61a72a50a084db1c332d7b041d51","impliedFormat":1},{"version":"fb1ab3eca9167ab9032e33e0d665756762ef124432b718b2d38aaaad8bd39c1c","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"44a01d3e816c26b06eb256430b1e280e0a726291f5853b8f7362adcb63024ac0","impliedFormat":1},{"version":"aed211990e01ce12149bcad9cb21eab2af37f9d1be87b573e537382b07125fd9","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"9f6c180974d631c5106375f8115034416bfc116d714da8111d593649fdfa6881","impliedFormat":1},{"version":"201223daa41ecabd73d374677e6c8a55286fbec8fd73fa1dbc3b299f9d93d7cb","impliedFormat":1},{"version":"8cc05f3a6b0cf87e4a8a3e281e8dfadd8724f2a3d7d6c1c1bbaa2058942d8587","impliedFormat":1},{"version":"23ce669e90071d01bbd080fc80768c1254b88fb27f882b4eb12f6ea7c3ca7245","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"5e286c586e00f9576df08f8d07aea04589a1ae6a47039ed3e25b746ce56be07b","impliedFormat":1},{"version":"aa1d36eefffe4293cd9a7f77475a229de9e679fd4dab35c53737689615413f00","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"8ea84a2aeaa6e3f0ee7536f290f21aa0516b1beeb8afd9a345746c202d4fecd5","impliedFormat":1},{"version":"d330cf8ad36f51ad2c0f52c05f4d3b4a87d4ec19c895965aa6d6bde2f921fa8b","impliedFormat":1},{"version":"a88a803521afb4cc68e15d63064d7e32814ae84db018b93b674ddd7cc78e829f","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"549210a66dd6dbfb35226043a10410ce86b2a63df7901c924ba8d3ef5cb69dd7","impliedFormat":1},{"version":"cb8555f754a4351c0be95806a593b70e320e8c64d678eee49253af63363d229d","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"e3fd2663e651c4faaf3c3d9f091e8baa099a15e8ac257d2a19ccbbde9ae74504","impliedFormat":1},{"version":"1012b44dfc8d4ebd93b1db8c0f6809640c19560d5c349a9f4aaabde95990749c","impliedFormat":1},{"version":"275419c8ff2ff8bfaeea639831fbf2b8ddd4f61dc4a4d328509711af8772a04c","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"d50a5a025d00f150c2451ff04c296efaaa75a11cb9af43b75d08286e9d1d3e1f","impliedFormat":1},{"version":"6c7e7af3556602691a6ec66db9ca7362edf92b479e495427d1799ea6724e5b7d","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"13dfae6ae7a21c488f1b151ed65171376f7567af6555e054b70886cbfe3d64ec","impliedFormat":1},{"version":"ca5bf0c55f9fbdb1de4d4b647aff0f3ca451919319d5f65b876608fc21a7e5f5","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"51058deec8dcb059b7e0da43c8ca334f9c24e5299786f6fff81c5c3115c0d9c5","impliedFormat":1},{"version":"33bb615855e9cb95ab454048b66152fc189cfcc815a71968f3fba0568a493dac","impliedFormat":1},{"version":"b390ca7159e608d30b54b570a0fd001444a449fbd4f435e62d812e99da4a6276","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"4bdd028f63f58023ee1e65970fbd7bd26725ac2b5b9a32ec254d6802dd2d6839","impliedFormat":1},{"version":"ee493507b1b489845c1058f7e4957673fc3c95055e4737b848eb912fcf4369f8","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"f60e3e3060207ac982da13363181fd7ee4beecc19a7c569f0d6bb034331066c2","impliedFormat":1},{"version":"17230b34bb564a3a2e36f9d3985372ccab4ad1722df2c43f7c5c2b553f68e5db","impliedFormat":1},{"version":"6e5c9272f6b3783be7bdddaf207cccdb8e033be3d14c5beacc03ae9d27d50929","impliedFormat":1},{"version":"9b4f7ff9681448c72abe38ea8eefd7ffe0c3aefe495137f02012a08801373f71","impliedFormat":1},{"version":"0dfe35191a04e8f9dc7caeb9f52f2ee07402736563d12cbccd15fb5f31ac877f","impliedFormat":1},{"version":"fd29886b17d20dc9a8145d3476309ac313de0ee3fe57db4ad88de91de1882fd8","impliedFormat":1},{"version":"63fdffffa7773c0110c9b67461c56446d62bf39c452c270c8beeb0ab21870bee","impliedFormat":1},{"version":"b0624a46904bd874431f1d59d8d2155e60699d1c9be157c3cccd4150fc46455a","impliedFormat":1},{"version":"9b1323fb6eb0cb74ad79f23e68e66560b9a7207a8b241ac8e23e8679d6171c00","impliedFormat":1},{"version":"23ce669e90071d01bbd080fc80768c1254b88fb27f882b4eb12f6ea7c3ca7245","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"29a4009b3beae9172a7c9458c37b0e96a8c5dd4e9d055600135e910d61ebc45a","impliedFormat":1},{"version":"644fa932306199825153f95e510281bb36a820c863b5c53fdfec8e52e62137ce","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"3a1f80230a0fd66214b15df2a92770ba15b738c213ae178e37f22b34a3fd3062","impliedFormat":1},{"version":"5a5e9b3ca5f42bfa83fda30c8a39fd98219f5fb9fd5ba85f2a021aeea8623143","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"1ef1bbbf4a3c7d3b73c46cddd38676ae0a06f1246695f03a197a04366a36f06e","impliedFormat":1},{"version":"ba7038cc4e567ed228310cb84241047dc53319e90014c0bb891d38fddb02507d","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"4662e96b5dfc4be98c737e5887250a37902e5f4344caeebd3931f93413b8b477","impliedFormat":1},{"version":"3968ca4a1e66ce617846f29a8f1df2ff7ac5c017ada33df67daddfc3ee6593c1","impliedFormat":1},{"version":"176c1830aa8f82bf2e8ececbad1a4313e0bb7d4d6210e506e4f68c9e72ddab83","impliedFormat":1},{"version":"90ceabba07e0b44b3e70475fad3b3942836a443854a3751d42c259f183ada9ba","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"ed00e6aed4e043e58d31fad90e23bd9a108237293387040a6e880a8be67dcdf9","impliedFormat":1},{"version":"df1b8e9365190a1246d8ccc9c6300437d869531ac8d0d156b377cadd8d326761","impliedFormat":1},{"version":"b390ca7159e608d30b54b570a0fd001444a449fbd4f435e62d812e99da4a6276","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"9e4164fb70ab758833958ccda26e38ef8d98b39f9dcd93c8f4dce7fd30740779","impliedFormat":1},{"version":"7ba487cfc9273e367ca0d1ab544fe2de1fb80a968e0ee6c704b47d2feabee471","impliedFormat":1},{"version":"e00528d92320adf35a8953c24d4fcf7fde7adbfb340404a569c07767875a4cc9","impliedFormat":1},{"version":"0d64e9d05fedc3c705e5c2f68574b3b4b8cfe767a6c6ea70a32d91a670392dbe","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"353f815015a871e01a77cb6fd1eeb73c51395b53ba42feafab9dfab354249988","impliedFormat":1},{"version":"31917366c856fbbccddfb9a0821ba5d66e0014ae13ed3f2a7ec8d367fcfe725a","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"4d16f16dd3771f67573c4807fa8b2d6e2ce442dc26c927e91084889ca466f759","impliedFormat":1},{"version":"4f3d1142ed46dcaa7822efb1ff31296541dd68672cdc5c8be668c24067d0df2d","impliedFormat":1},{"version":"3bbcabae328869f3531eaac3c236213ab138ec74e5ed31e709e940340bc1ffe6","impliedFormat":1},{"version":"e0eb2938d78e30af06783046057c657669e293d399b1b9ee8e56d457f532e006","impliedFormat":1},{"version":"5cb00927cbb410110dde3fb0fda5f1b093f53af27a8e6869233315c635d78708","impliedFormat":1},{"version":"aa15fa0665f8d77bb5605cfb153562eb71f2c21192db8f59bb5d3407f09bb199","impliedFormat":1},{"version":"bd756cd32d8a21382275df48f3004998be174e82ae4987195527727593fea1aa","impliedFormat":1},{"version":"3bfa6a67474a2dc79269d90a333aa4bd48a66dd5687e5d6e4826e2bef671a047","impliedFormat":1},{"version":"20064a8528651a0718e3a486f09a0fd9f39aaca3286aea63ddeb89a4428eab2b","impliedFormat":1},{"version":"743da6529a5777d7b68d0c6c2b006800d66e078e3b8391832121981d61cd0abc","impliedFormat":1},{"version":"f87c199c9f52878c8a2f418af250ccfc80f2419d0bd9b8aebf4d4822595d654f","impliedFormat":1},{"version":"57397be192782bd8bedf04faa9eea2b59de3e0cfa1d69367f621065e7abd253b","impliedFormat":1},{"version":"df9e6f89f923a5e8acf9ce879ec70b4b2d8d744c3fb8a54993396b19660ac42a","impliedFormat":1},{"version":"175628176d1c2430092d82b06895e072176d92d6627b661c8ea85bee65232f6e","impliedFormat":1},{"version":"21625e9b1e7687f847a48347d9b77ce02b9631e8f14990cffb7689236e95f2bb","impliedFormat":1},{"version":"483fad2b4ebaabd01e983d596e2bb883121165660060f498f7f056fecd6fb56a","impliedFormat":1},{"version":"6a089039922bf00f81957eafd1da251adb0201a21dcb8124bcfed14be0e5b37d","impliedFormat":1},{"version":"6cd1c25b356e9f7100ca69219522a21768ae3ea9a0273a3cc8c4af0cbd0a3404","impliedFormat":1},{"version":"201497a1cbe0d7c5145acd9bf1b663737f1c3a03d4ecffd2d7e15da74da4aaf1","impliedFormat":1},{"version":"66e92a7b3d38c8fa4d007b734be3cdcd4ded6292753a0c86976ac92ae2551926","impliedFormat":1},{"version":"a8e88f5e01065a9ab3c99ff5e35a669fdb7ae878a03b53895af35e1130326c15","impliedFormat":1},{"version":"05a8dfa81435f82b89ecbcb8b0e81eb696fac0a3c3f657a2375a4630d4f94115","impliedFormat":1},{"version":"5773e4f6ac407d1eff8ef11ccaa17e4340a7da6b96b2e346821ebd5fff9f6e30","impliedFormat":1},{"version":"c736dd6013cac2c57dffb183f9064ddd6723be3dfc0da1845c9e8a9921fc53bb","impliedFormat":1},{"version":"7b43949c0c0a169c6e44dcdf5b146f5115b98fa9d1054e8a7b420d28f2e6358f","impliedFormat":1},{"version":"b46549d078955775366586a31e75028e24ad1f3c4bc1e75ad51447c717151c68","impliedFormat":1},{"version":"34dd068c2a955f4272db0f9fdafb6b0871db4ec8f1f044dfc5c956065902fe1c","impliedFormat":1},{"version":"e5854625da370345ba85c29208ae67c2ae17a8dbf49f24c8ed880c9af2fe95b2","impliedFormat":1},{"version":"cf1f7b8b712d5db28e180d907b3dd2ba7949efcfec81ec30feb229eee644bda4","impliedFormat":1},{"version":"2423fa71d467235a0abffb4169e4650714d37461a8b51dc4e523169e6caac9b8","impliedFormat":1},{"version":"4de5d28c3bc76943453df1a00435eb6f81d0b61aa08ff34ae9c64dd8e0800544","impliedFormat":1},{"version":"f3872b85af5ffecb00b3c5a68df24f931821e8027c8c9c6574ce3925d34210a0","impliedFormat":1},{"version":"04b8c9cc7d8c12b48f7e2a311d244fd2419370dbd9a78437e40d2133c8b79116","impliedFormat":1},{"version":"70f7634df4057b4589a7237f8f5bd4e9b4a87090e3a229daca6a77b0aeeedf74","impliedFormat":1},{"version":"41ca214cf922678daa4dbfbe0f72cc9ac9c9858baced90041a64d4b29430fb25","impliedFormat":1},{"version":"e6872602b3df829d8f917a3041aa2d6d65cfde2bf02c881f0a623139aa30771c","impliedFormat":1},{"version":"793b9f1b275af203f9751081adfe2dc11d17690fd5863d97bd90b539fa38c948","impliedFormat":1},{"version":"3a5f7910453d0bfd3cc3935a43f4db5472a0c8d9c9c9a13047bafb07e94a365d","impliedFormat":1},{"version":"4d6739cdb0281c821c4b32c34fd27bd645f44ecb1d94faeef3778ba56f48e849","impliedFormat":1},{"version":"a089122411d0b1ff69f29c69bb6508f7b2a05217ec4dc59cfbf4ca94438eb335","impliedFormat":1},{"version":"fc2a37ee713244cb7637c234c7a5f9e28a528f9c57900b0d2115582c5b1ca1fc","impliedFormat":1},{"version":"c67beadff16a8139f87dc9c07581500d88abd21e8436c9e9bf25f2ee39c5b1af","impliedFormat":1},{"version":"3eac16a8b13d721047f5c5ee8c5a90d9e17cbdbe42f12070310730b2a0f55d19","impliedFormat":1},{"version":"5db8a2f466979772e79c4359fa57fa77c77702246c8d42e5d3450292edc6c7b1","impliedFormat":1},{"version":"a48576aab4a71ef8d9910a7de69aa03e2765bf0581bbb4dc041be3be601f005e","impliedFormat":1},{"version":"a61fe1d36e52610853e709fd0dab30de2b53e3d7afe5ad336696492a7eda0877","impliedFormat":1},{"version":"42dbc7f80df0369abc6376234898767a47de30809d40e1668878d47123bd2802","impliedFormat":1},{"version":"7c8266350412c20023ad6f78deccec313c804e82167f1d8367f5403cbf2e9dcb","impliedFormat":1},{"version":"8c4eacbd89171a62110657df3eeed414077e651a01578fea82e56092a0608fa3","impliedFormat":1},{"version":"3de634975d27bf67ff397484ae26e60f1a32b211f4709e921ad3be76c07fa0d9","impliedFormat":1},{"version":"342a37c1b97735df61fdeb2497fde2771bcdcadcaaebdd1d626d4b51d3bc164d","impliedFormat":1},{"version":"c67beadff16a8139f87dc9c07581500d88abd21e8436c9e9bf25f2ee39c5b1af","impliedFormat":1},{"version":"526f860ab047358ccdd6cd2de52ebbb0022cdecaf3af842f74fa2dd3a1ab556b","impliedFormat":1},{"version":"310cb56898b50696ce10cff66102aca94c85833bf24effa10c434673c2d57f4c","impliedFormat":1},{"version":"ad62415a113c9a3556e3dc4557a5389735ab8a6b7c7835b11be9b7ae8ada0561","impliedFormat":1},{"version":"8f46cccec5c65f65525d6753c441bdacec11294a63ed05fe251266b51ba81a07","impliedFormat":1},{"version":"733cc50ddf8b7bf538f7a27f4a90ddfe3192dd7c8ed6bbe46fbb9936c845da46","impliedFormat":1},{"version":"e1f0dc186e3dc4f7ad9d4b7b9f951a9f9a667048dbfaca5115fe3a78ed0f58c6","impliedFormat":1},{"version":"4507eb375ee3a0816f012d84c4bc0171974c862642975e37c2c9cb9c89bd49e4","impliedFormat":1},{"version":"2c7fe18208f5261a806b8ad09c6637da592ba28996b52d8134c1cb7ca6076c65","impliedFormat":1},{"version":"4fd924ab2654220f6329b7b7bd2a6c8bed0cbd93a9981852bd47bc12850612bb","impliedFormat":1},{"version":"7ac248b38b0ff3e7115bb57e6f73f89e113b96e0fefb7f1f8346223150f01dd8","impliedFormat":1},{"version":"5931d89ff88d6e539703ff5f45bae9bef24fa19049274d108763d52ac621f2e4","impliedFormat":1},{"version":"6ffdc76b9e208eefd925012a94c946b2ce062ab3d673523988a3cd686bf8755f","impliedFormat":1},{"version":"b1c2a744c378fda7e753464918f9ed8b61c5a9c8b199ce85ba387e398f89e33e","impliedFormat":1},{"version":"f2668c3bc4f5fd14278e682aa372c9065db628c65d21f375f455ffbd13c32dfa","impliedFormat":1},{"version":"e45caa12a199be3902e9992a6aa25fb47d6d1d4e7336c8086c8d45da7d61266c","impliedFormat":1},{"version":"14a7f2c42518544f56878a5ed889f5a691aabc0a8b41a75a9b8ece876d8cae4b","impliedFormat":1},{"version":"c2b3e96c52ed37ba06e006bfc4655ac89fb2769b5c605149237c8865314b08ab","impliedFormat":1},{"version":"53f751014cc08afeae6c3199b89b0ab0718e4f97da8b7845c5b2333748277938","impliedFormat":1},{"version":"730bc59b59a58a530d2ed0b995776db32a983aa8e1729724ea3e227e8b273133","impliedFormat":1},{"version":"9876c3b27f281f61ddb9f8561eb0d3635647a61b35a102a7298ddf4437ebeb69","signature":"4eefb97bbee25bc4568d3f07cf45625aabcb068a3515a5463845a460f75b19d9","impliedFormat":99},{"version":"c45bb00c7d4f9ea3e5d9efcd86054b676b9b5b0779b624940ff130ab5e7829f9","impliedFormat":1},{"version":"98627be5a8afec6799fe0e2a903e9d8e6afbbdf7dc405bf79d98d118f16143e9","impliedFormat":1},{"version":"f767ea48a88771f27e250da6a1757f2fbed727f759e72dd00e87c39af8e6278d","impliedFormat":1},{"version":"4c5c4c5931cf4c37400b0aa318750e1c2da52ae3d274923973268d1e6c9bca31","impliedFormat":1},{"version":"dbfa8af0021ddb4ddebe1b279b46e5bccf05f473c178041b3b859b1d535dd1e5","impliedFormat":1},{"version":"7ab2721483b53d5551175e29a383283242704c217695378e2462c16de44aff1a","impliedFormat":1},{"version":"ebafa97de59db1a26c71b59fa4ee674c91d85a24a29d715e29e4db58b5ff267d","impliedFormat":1},{"version":"16ba4c64c1c5a52cc6f1b4e1fa084b82b273a5310ae7bc1206c877be7de45d03","impliedFormat":1},{"version":"1538a8a715f841d0a130b6542c72aea01d55d6aa515910dfef356185acf3b252","impliedFormat":1},{"version":"68eeb3d2d97a86a2c037e1268f059220899861172e426b656740effd93f63a45","impliedFormat":1},{"version":"d5689cb5d542c8e901195d8df6c2011a516d5f14c6a2283ffdaae381f5c38c01","impliedFormat":1},{"version":"9974861cff8cb8736b8784879fe44daca78bc2e621fc7828b0c2cf03b184a9e5","impliedFormat":1},{"version":"675e5ac3410a9a186dd746e7b2b5612fa77c49f534283876ffc0c58257da2be7","impliedFormat":1},{"version":"951a8f023da2905ae4d00418539ff190c01d8a34c8d8616b3982ff50c994bbb6","impliedFormat":1},{"version":"8cfe5ad847a1e073099e64ce97e91c0c14d8d88aaefcff5073aa4dda17f3067f","impliedFormat":1},{"version":"955c80622de0580d047d9ccdb1590e589c666c9240f63d2c5159e0732ab0a02e","impliedFormat":1},{"version":"e4b31fc1a59b688d30ff95f5a511bfb05e340097981e0de3e03419cbefe36c0e","impliedFormat":1},{"version":"16a2ac3ba047eddda3a381e6dac30b2e14e84459967f86013c97b5d8959276f3","impliedFormat":1},{"version":"45f1c5dbeb6bbf16c32492ba182c17449ab18d2d448cc2751c779275be0713d8","impliedFormat":1},{"version":"23d9f0f07f316bc244ffaaec77ae8e75219fb8b6697d1455916bc2153a312916","impliedFormat":1},{"version":"eac028a74dba3e0c2aa785031b7df83586beab4efce9da4903b2f3abad293d3a","impliedFormat":1},{"version":"8d22beed3e8bbf57e0adbc986f3b96011eef317fd0adadccd401bcb45d6ee57e","impliedFormat":1},{"version":"3a1fc0aae490201663c926fde22e6203a8ac6aa4c01c7f5532d2dcdde5b512f5","impliedFormat":1},{"version":"4fbae6249d3c80cc85a1d33de46f350678f8af87b9566abce87e6e22960271b7","impliedFormat":1},{"version":"d36c6f1f19a6c298a6e10f87d9b1f2d05e528251bbe351f95b1b805b42c2d627","impliedFormat":1},{"version":"a7f590406204026bf49d737edb9d605bb181d0675e5894a6b80714bbc525f3df","impliedFormat":1},{"version":"533039607e507410c858c1fa607d473deacb25c8bf0c3f1bd74873af5210e9a0","impliedFormat":1},{"version":"b09561e71ae9feab2e4d2b06ceb7b89de7fad8d6e3dc556c33021f20b0fb88c4","impliedFormat":1},{"version":"dd79d768006bfd8dd46cf60f7470dca0c8fa25a56ac8778e40bd46f873bd5687","impliedFormat":1},{"version":"4daacd053dd57d50a8cdf110f5bc9bb18df43cd9bcc784a2a6979884e5f313de","impliedFormat":1},{"version":"d103fff68cd233722eea9e4e6adfb50c0c36cc4a2539c50601b0464e33e4f702","impliedFormat":1},{"version":"3c6d8041b0c8db6f74f1fd9816cd14104bcd9b7899b38653eb082e3bdcfe64d7","impliedFormat":1},{"version":"4207e6f2556e3e9f7daa5d1dd1fdaa294f7d766ebea653846518af48a41dd8e0","impliedFormat":1},{"version":"c94b3332d328b45216078155ba5228b4b4f500d6282ac1def812f70f0306ed1c","impliedFormat":1},{"version":"43497bdd2d9b53afad7eed81fb5656a36c3a6c735971c1eed576d18d3e1b8345","impliedFormat":1},{"version":"5db2d64cfcfbc8df01eda87ce5937cb8af952f8ba8bbc8fd2a8ef10783614ca7","impliedFormat":1},{"version":"b13319e9b7e8a9172330a364416d483c98f3672606695b40af167754c91fa4ec","impliedFormat":1},{"version":"7f8a5e8fc773c089c8ca1b27a6fea3b4b1abc8e80ca0dd5c17086bbed1df6eaa","impliedFormat":1},{"version":"0d54e6e53636877755ac3e2fab3e03e2843c8ca7d5f6f8a18bbf5702d3771323","impliedFormat":1},{"version":"124b96661046ec3f63b7590dc13579d4f69df5bb42fa6d3e257c437835a68b4d","impliedFormat":1},{"version":"0e7b3f288bf35c62c2534388a82aa0976c4d9ebaf6ebe5643336c67ed55e981d","impliedFormat":1},{"version":"724775a12f87fc7005c3805c77265374a28fb3bc93c394a96e2b4ffee9dde65d","impliedFormat":1},{"version":"431f29f17261cff4937375ff478f8f0d992059c0a2b266cc64030fb0e736ce74","impliedFormat":1},{"version":"ff3f1d258bd14ca6bbf7c7158580b486d199e317fc4c433f98f13b31e6bb5723","impliedFormat":1},{"version":"a3f1cac717a25f5b8b6df9deef8fc8d0a0726390fdaa83aed55be430cd532ebf","impliedFormat":1},{"version":"f1a1edb271da27e2d8925a68db1eb8b16d8190037eb44a324b826e54f97e315f","impliedFormat":1},{"version":"1553d16fb752521327f101465a3844fe73684503fdd10bed79bd886c6d72a1bc","impliedFormat":1},{"version":"07ea97f8e11cedfb35f22c5cab2f7aacd8721df7a9052fb577f9ba400932933b","impliedFormat":1},{"version":"66ab54a2a098a1f22918bd47dc7af1d1a8e8428aa9c3cb5ef5ed0fef45a13fa4","impliedFormat":1},{"version":"f3c511e1d8b463dc37eaf777b0a620cbd4dd2fe448a16413dc300a831c397b91","impliedFormat":1},{"version":"bf22ee38d4d989e1c72307ab701557022e074e66940cf3d03efa9beb72224723","impliedFormat":1},{"version":"158c190bebda38391b1235408b978e1b2b3366b92539042f43ae5479bfcb1a5e","impliedFormat":1},{"version":"271119c7cbd09036fd8bd555144ec0ea54d43b59bcb3d8733995c8ef94cb620b","impliedFormat":1},{"version":"5a51eff6f27604597e929b13ee67a39267df8f44bbd6a634417ed561a2fa05d6","impliedFormat":1},{"version":"1f93b377bb06ed9de4dc4eb664878edb8dcac61822f6e7633ca99a3d4a1d85da","impliedFormat":1},{"version":"53e77c7bf8f076340edde20bf00088543230ba19c198346112af35140a0cfac5","impliedFormat":1},{"version":"cec6a5e638d005c00dd6b1eaafe6179e835022f8438ff210ddb3fe0ae76f4bf9","impliedFormat":1},{"version":"c264c5bb2f6ec6cea1f9b159b841fc8f6f6a87eb279fef6c471b127c41001034","impliedFormat":1},{"version":"ff42cc408214648895c1de8ada2143edc3379b5cbb7667d5add8b0b3630c9634","impliedFormat":1},{"version":"c9018ca6314539bf92981ab4f6bc045d7caaff9f798ce7e89d60bb1bb70f579c","impliedFormat":1},{"version":"d74c5b76c1c964a2e80a54f759de4b35003b7f5969fb9f6958bd263dcc86d288","impliedFormat":1},{"version":"b83a3738f76980505205e6c88ca03823d01b1aa48b3700e8ba69f47d72ab8d0f","impliedFormat":1},{"version":"01b9f216ada543f5c9a37fbc24d80a0113bda8c7c2c057d0d1414cde801e5f9d","impliedFormat":1},{"version":"f1e9397225a760524141dc52b1ca670084bde5272e56db1bd0ad8c8bea8c1c30","impliedFormat":1},{"version":"08c43afe12ba92c1482fc4727aab5f788a83fd49339eb0b43ad01ed2b5ad6066","impliedFormat":1},{"version":"6066b918eb4475bfcce362999f7199ce5df84cea78bd55ed338da57c73043d45","impliedFormat":1},{"version":"c67beadff16a8139f87dc9c07581500d88abd21e8436c9e9bf25f2ee39c5b1af","impliedFormat":1},{"version":"bd48c46838f76d5b24e8840ed273cbc18d21f914e1207dc993ef5a91d30cc0f0","signature":"7f798202f2601d6231a6a5d14b9d21fb08bbf96cac959df8e801072a6a329d97","impliedFormat":99},{"version":"46fe31a9945da91bc8c9bdebbd1b1b60a473009b4d7defef32c8508da60e1759","signature":"f028a85c161290983ee81a30ef42de3678e039c47b2067c65f05b69baf6ba520","impliedFormat":99},{"version":"5262ef8f7c4de6825bed32262ca307a20c1dce25cba04a0ac62533c2fb209e00","signature":"01cbd1e1073b63573d1f98301b919306abed16923b6f4d98845e5de9d651b206","impliedFormat":99},{"version":"7318a34a0de5de63a3a93dbdc72bba40984aa499bdf3e93c18a357797b93e237","signature":"aac63d88a32901a04c9031906ae29b52a6faafba201eba535f936eac54505c87","impliedFormat":99},{"version":"54e56ff9645fecdc537365071a733ed48f5e1735ab091b206c0ac38048c46b8d","signature":"190ad12d136721e113372b8b98efc436e4cd1f2da0f948ce24e1ca70e1cf94b2","impliedFormat":99},{"version":"73778a1cb727b5f214c14224dd6f36063c7b13c1b995143a0c1637d84a9866c2","signature":"55bf030bd1c94b2de8cb2962d1daa19d1669e7347172f49da306b925194f63fc","impliedFormat":99},{"version":"ed513eeb771076b84dc9dba88de8910b7e0d286e1dcf2576e91ff7c771ec963f","signature":"d26e72a29d50c12ba81797cc52d6006350a0a0d58393291253b5066c691a2878","impliedFormat":99},{"version":"25cd20012c1f465659036eca468bdac5e818ab92fcaa2e90f7127b5b602c1b0a","signature":"86f14e636f8f4c41968f90fef5d0922c16248f722ee28d68cc04c6fc7003ef16","impliedFormat":99},{"version":"dce98004198c1ec40cbd2437d4928c1ac87333530f1e56ca32277ef23e91161b","signature":"61f34bdf208c02b866015648908b62c3dd5b4350fef52cf99c0d0034054a0e8e","impliedFormat":99},{"version":"41d7605fd977af81f1d79905b0b60740286cb10ba26a2a6c08eda77ac3b39a9b","signature":"220fb625d77c274d8bd6745f6fb6562719ec88e8c2d2f5a338c7c5f4dff717fc","impliedFormat":99},{"version":"e1e4f99cdafa625549aebe2667282cf3ca39e7455ba41d067785a83d4f2c86c8","signature":"b3dbe72f7a17599cad3df304f38dc44bdfe39314496cd2fb42215e3885b39a83","impliedFormat":99},{"version":"d5cd68749e5b9605f9ae4a4fc445acfffac826b64e48798ecf39219dce43e88f","signature":"3db753426975ea577b1e1547b6b8003990fad102cc5722623c17fd768d7b8416","impliedFormat":99},{"version":"3a871f18851a6b1ef99ba0266fa22b11604c7089daa20f4b075c1709089b7c98","signature":"4b69e306b6ae33b29b9fcce8cfb591a98f441663e053682d22dcc18ed70f8d5e","impliedFormat":99},{"version":"4e23d5e8f9190ac9c9f4d3030c465f4d4576f247667d1661f42bab15983bd4db","signature":"06a7727cca254c735fe5f81e096c318d7a78203afab3ea91a6743f057481dc8a","impliedFormat":99},{"version":"fa8c053580fa699b6324d394f7c5205db5853d9e6f2f4598d7f5b5c829c2559a","signature":"1967d5eb17d7997ab2c2980bb75fc81b993d79fc23c11311ef458bbc8d4a67b8","impliedFormat":99},{"version":"10f9d14746a3bfe0f1b61a7a9aeda1d7c7c9557c9e838f7dca139aa538ca85aa","signature":"37c0fac0cfd565a0e4ad0cc2f0300e79954b0606f69f27b35c5bf7be396c4bbc","impliedFormat":99},{"version":"2684b31088c6ff5dae5b640d6701f84c8e79847cde98cb146f31225419bf095d","signature":"5078d52c0d1565ccbb69fe994ce9fe7b890d829593c3c5e81bdaa494a268e68b","impliedFormat":99},{"version":"50bea882b06df323ec32cf705eb74b4c9b7fc9b2cc674eca07a3e1c3a4301844","signature":"e8eed53ba4930be609a2f3e99f1fda1d2deecb0a505fbd7349c148b7849a1952","impliedFormat":99},{"version":"f90a86804281cc590236b4a5fac7ad7cd78b6ee1f2244f3ca83cfe584491fe44","signature":"24d5a8ce7f3c52c0aab00b8e0b3c0c5758e54ccc6576e3867a3f070f2cc62998","impliedFormat":99},{"version":"5ee35b2e8606be7c714e64a15c4175b4f2d07c6de19f75fa5e9f968c67defd1c","signature":"1ed109282ec247938156efc6dd4ede1ceb14c9cd835b151ec4c99f54370815a2","impliedFormat":99},{"version":"2cad5f48c4742b532509dd252c0203a6f591b68b7428df8009eaae6c6203fde7","signature":"43145d1d295074d5da4f6e3b2a3f96461d955618139845c496af237ce17cf677","impliedFormat":99},{"version":"8db3648f7e5c953e75ef201b3a5bfc89ec70dd95ea41296679820dab939a4209","signature":"688dcce6410ae7b1c312d188f655bdafee7574a8040ff71c48ace2fcc5b798de","impliedFormat":99},{"version":"c5049011a3327b1a21d5bb49d26b240d03c09223c1f2689fe010e4a8a4a21a92","signature":"94e6115212fcbf3f5503659ba576bf1acd8ce52bab6cce0a0fe22af285132136","impliedFormat":99},{"version":"2e167ae316aed3f4922b3ed272ca46c39419af6b2f19d2d1872db589c0aab3f2","signature":"86959458261191c63c09daf307327e43108d26053275dbea4ac668b57c459315","impliedFormat":99},{"version":"2e47890e3f7ae1260fe5b50f34a5c44ea893e62c4881a2a025e76322e5e8fad3","signature":"6bac498ac2a80c45d3722a06d587d15bff484d1712dfc42b5df6ea940c44ffa5","impliedFormat":99},{"version":"d00062f4a6532c33128212a4572523f5b2004a2ae6944e240e52d021909b2897","signature":"ca768cbb64f8284683ccea8dcd0620f5d8adaa5c4ae70c3de9a558a18444729b","impliedFormat":99},{"version":"bfb166d4641c40dff774aa959a00a4a96424052a6a50a7c10b13bd83f34d6bef","signature":"5bf1b32fb9646b7f2cd356ed8c45dd009ddf6779cb989a68524a333f131341b7","impliedFormat":99},{"version":"753b1dbd92a1fb635ee3d7900d1b9cab0d9c522c4bd875ab3da6ecfb56f5dd73","signature":"44beb9d9b0251d24745fcfe5c99da95e645176f8fd50781110ea08bf3406ec8b","impliedFormat":99},{"version":"017ca42baf30951214417f198fc22b827f1fd98f81a2479c453df14dfc992672","signature":"5a85efaae2c2dc1c9e2d481654a86248910bdf29a3bf8ea26b0df19b980cc795","impliedFormat":99},{"version":"808e403342df813bd24b379abf9a12d39f6f45ef0846f289876b3bcc333dfaa4","signature":"408d0918dc7fc5d15dcc5c7bcd2ccc2882fb4c1c5df429b2076af1bfb54e9dbe","impliedFormat":99},{"version":"1bd46809884a2cc64c7e8581a09d8eb581259eb93597a29a9a924cff6567b429","signature":"f8a78a89fbbe4280a0fb1ba0b987f80c5614acb27238f3e8af32762f9b0ada46","impliedFormat":99},{"version":"066c22597579927b2ccb606e3799285a26fda7b3dd4157e85627f30148ba89aa","signature":"ea7cb5aa42615ed23d948feabc4dd71d75527575e328e9130a2efe4bd31766d2","impliedFormat":99},{"version":"e8a84b8799a5127f2f825bfb3d6f27f32cf8d6aeed6999724754b292973e8f94","signature":"21ce89e9055ac685364b7d06b0494a75323d087cbe9eb008ec0f12ccb4211421","impliedFormat":99},{"version":"1a5a6c703dcc9b101b75aaedf75e871296a4203863e2c5a915b841bb8ab888f6","signature":"fb0f811fa1f01076e903e095e9086d32732e5145ea43cbc4f8d76bb220453177","impliedFormat":99},{"version":"354f11017c689040f3a2a3f124dafc16a7830cb25ff932b661b98929fc14befe","signature":"678e8470f95b0b9299a12ad20f8f045797803dbfe44bca4536c10874be31a2fa","impliedFormat":99},{"version":"6ee8a3729e995a0aa27a1dbfbecdb2550fa955768d4b9760a627e7d7e16e6230","signature":"d753596a0abfecc294e2322241706070ce68acc476c7500357bbdc36b6d5b0f7","impliedFormat":99},{"version":"08e90840eee698b730e58cec0e3431b16f938b506f1a21d5bf90b85b0f05046e","signature":"0a6379ac97d27afca540e6f999999ec5b1b180745eb78b47f1c427459bdae029","impliedFormat":99},{"version":"b74fd725749d41345446f4ba81c0e44bb49a1a35046359b44d6653a0e24686ce","signature":"163a88b3c3a7253dd243a6be107bae6b6939e61f710377d8fabc1551c8a40f6d","impliedFormat":99},{"version":"6a84131f39c294ae8fce9836127ee2979712cc8700805288251518067e887707","impliedFormat":99},{"version":"0162d6e1c415403abfe5b9e3e3f08f1df1aee3b2c5acafbbef1be0aa7766f4e2","impliedFormat":99},{"version":"5a13b33735a171319158162c7c37cb0a1a03cac7a82cc7e3650e8576e70f5f18","affectsGlobalScope":true,"impliedFormat":99},{"version":"e915cb45881a8711c5c95d7705ac649059f419a7474fe420b4e73670cb761261","impliedFormat":99},{"version":"6ba9fb31ef06af910dfc547de2c001a73c7bb0c9863244935775d59caf7432ad","impliedFormat":99},{"version":"e4b726cafa6c049a937aa10f1a2f8f0ef63c081fa4d9e2b82a4d18ae2634bba8","impliedFormat":99},{"version":"826cc59a64a4b14e20a8939353bd9927e979811bde97d269b974353aeb9700e9","impliedFormat":99},{"version":"e6badbbd1a6a9e60bcb5fd19a1c3d7ed16e44bab0ae9059dcc8949188faa8b3b","signature":"28317baa664c7e97d0d8edd7d785948827ef2f754d7126a530f9750199586fbc","impliedFormat":99},{"version":"8c38a00cb26a9797c626397de43ff45fb00fb329b4254e9bcc3dc2ca812825fe","signature":"9554d7e887b4356cea69aee8dd7b6977dec67da64e06787ad462892c77fac278","impliedFormat":99},{"version":"bf65fdc8828960e305b1ba4dc0d34157d8b4db6e23079fdf6b542376c121d69d","signature":"7457524d1fd8db43989bb3f09dddc48ecb58a482c4284b52444739f4729241d6","impliedFormat":99},{"version":"baa318646c1b1cf71ca56b448475af88ff9b5347be170127659750f35192a466","signature":"dfbc3a85ed381064dff4bb0ba2371282dbb87ee94c3ec0e28abfe5842eb09053","impliedFormat":99},{"version":"4181f88192bd6b520bddd0838e63b3576ddb549a8d80b4b56f1c10c2b8166c12","signature":"a83c6383cc9e66853eb2f8ffbefff2a8fe2fe3d9d7d7b972a9d8f17a6901be3f","impliedFormat":99},{"version":"5ab835404fd289adc08180014771e4d5f7b800f8b6b876772953f17437510186","signature":"db1f0b29ba27842a138f1b2f0c50354c7d24e87c9f40ac70c390053c64df2ee2","impliedFormat":99},{"version":"f084332dd8a0de8f6f9cdcbca07c681f2dd34cf4f35d45517bee19c99367fa29","signature":"7365f07329e5361d04e0adc23776d544d98c2a28629ba791651fe1ef7c0688ba","impliedFormat":99},{"version":"5c09e73df38a6c0e64347f73b5be9b9f85c758abd12dbf259e59b548a24c3cd8","signature":"d136ea06777deafb51594e4ea6b079fc0a0b4ec0a51c0e0cd3f9d7cd84c0b918","impliedFormat":99},{"version":"d1de6ff1c1e01f9f6b3b2a755fdafb0e28ab3553bd22e43b556b63395c27a69b","signature":"c96e5b9d15cb2eccc1fd4db2899272f4a76c529b34bc495eae59544c56a8998d","impliedFormat":99},{"version":"130ddead3f9db34a2c00f78ed9811253c1701cbcd0da97e3f1abc4ea704bb854","signature":"81db7b14804a64be0c0319586fa4fbde71ef638c43b287d3c76d52c086373bff","impliedFormat":99},{"version":"7960751175e1b8aaf62dc375e92773a9079f92b6dfc2cd06f82e95959567dd31","signature":"86e32bfa2efea2de0eafc4a4e05593b46e93839ef6193b806b86a405087d90a1","impliedFormat":99},{"version":"c919a95b47f0fb266cd9232f2a3d1370a7d0fd51c2b9dbe63be0b0542e733eec","signature":"ad969ad9a47361df948034c1aef016b8f9f47dedb9ee5370d99e68902ddb6fff","impliedFormat":99},{"version":"1f3363474aa5306b2888a4133642aab2d6fd53c8056f9a73674062d523eaeecf","signature":"ce42c5fbdbbb826956d6cfe6489d56b571cf796fa0eea416889e7208a9ee7ede","impliedFormat":99},{"version":"90274a71de2c682975388b0f8072519b1e5c6e5076121679a058945d9d492803","signature":"1e12e614b1f898cb425a14dd78cef47ad5767023c984766cf98874b1ec7ad074","impliedFormat":99},{"version":"afe7eecddae922e93084de3a14ab41ecb3e873e7a3f23c228d799950fff90978","signature":"12a5ce45533a11e24c45f8df70d5ee93335f313246be27944c20c97d64d2eaae","impliedFormat":99},{"version":"2271e97436a9e0512b2d9fd25b15e75fb52a1961dccb7fe5d05ebe69a32c0581","signature":"373a9b7ef445e64e7de5a5e137e8ed735f147b9cd74a83cb22626643e641ab8a","impliedFormat":99},{"version":"72889c3f6589230fe33db4e866f7d755177eb5f3d20a949bed0476eca659aea9","signature":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":99},{"version":"b3691dfeb7cce60ed4bc516fb50263054cf770ff3772182ef4c1073b61eb27d8","signature":"90cdd065d4cd927c677fdef253e26d4545a12d02b8465feda3dfcbf678043979","impliedFormat":99},{"version":"7cdb80aa4b77c4d19ad4739696a72c5f1604c0086c511063005fe1f31066353f","signature":"4eefb97bbee25bc4568d3f07cf45625aabcb068a3515a5463845a460f75b19d9","impliedFormat":1},{"version":"5fb46bf84a85cf5e924e30465b7f919c777a1a03af44ae8c273d2ca229dcfd44","impliedFormat":1},{"version":"427fe2004642504828c1476d0af4270e6ad4db6de78c0b5da3e4c5ca95052a99","impliedFormat":1},{"version":"c8905dbea83f3220676a669366cd8c1acef56af4d9d72a8b2241b1d044bb4302","affectsGlobalScope":true,"impliedFormat":99},{"version":"151ff381ef9ff8da2da9b9663ebf657eac35c4c9a19183420c05728f31a6761d","impliedFormat":1},{"version":"037817934c90357f71eea18fb643b1fd7e6763fec011f5da1f0fb17acad09d62","impliedFormat":1},{"version":"073ca26c96184db9941b5ec0ddea6981c9b816156d9095747809e524fdd90e35","impliedFormat":1},{"version":"e41d17a2ec23306d953cda34e573ed62954ca6ea9b8c8b74e013d07a6886ce47","impliedFormat":1},{"version":"241bd4add06f06f0699dcd58f3b334718d85e3045d9e9d4fa556f11f4d1569c1","impliedFormat":1},{"version":"2ae3787e1498b20aad1b9c2ee9ea517ec30e89b70d242d8e3e52d1e091039695","impliedFormat":1},{"version":"c7c72c4cffb1bc83617eefed71ed68cc89df73cab9e19507ccdecb3e72b4967e","affectsGlobalScope":true,"impliedFormat":1},{"version":"b8bff8a60af0173430b18d9c3e5c443eaa3c515617210c0c7b3d2e1743c19ecb","impliedFormat":1},{"version":"38b38db08e7121828294dec10957a7a9ff263e33e2a904b346516d4a4acca482","impliedFormat":1},{"version":"a76ebdf2579e68e4cfe618269c47e5a12a4e045c2805ed7f7ab37af8daa6b091","impliedFormat":1},{"version":"8a2aaea564939c22be05d665cc955996721bad6d43148f8fa21ae8f64afecd37","impliedFormat":1},{"version":"e59d36b7b6e8ba2dd36d032a5f5c279d2460968c8b4e691ca384f118fb09b52a","impliedFormat":1},{"version":"e96885c0684c9042ec72a9a43ef977f6b4b4a2728f4b9e737edcbaa0c74e5bf6","impliedFormat":1},{"version":"95950a187596e206d32d5d9c7b932901088c65ed8f9040e614aa8e321e0225ef","impliedFormat":1},{"version":"89e061244da3fc21b7330f4bd32f47c1813dd4d7f1dc3d0883d88943f035b993","impliedFormat":1},{"version":"e46558c2e04d06207b080138678020448e7fc201f3d69c2601b0d1456105f29a","impliedFormat":1},{"version":"71549375db52b1163411dba383b5f4618bdf35dc57fa327a1c7d135cf9bf67d1","impliedFormat":1},{"version":"7e6b2d61d6215a4e82ea75bc31a80ebb8ad0c2b37a60c10c70dd671e8d9d6d5d","impliedFormat":1},{"version":"78bea05df2896083cca28ed75784dde46d4b194984e8fc559123b56873580a23","impliedFormat":1},{"version":"5dd04ced37b7ea09f29d277db11f160df7fd73ba8b9dba86cb25552e0653a637","impliedFormat":1},{"version":"f74b81712e06605677ae1f061600201c425430151f95b5ef4d04387ad7617e6a","impliedFormat":1},{"version":"9a72847fcf4ac937e352d40810f7b7aec7422d9178451148296cf1aa19467620","impliedFormat":1},{"version":"3ae18f60e0b96fa1e025059b7d25b3247ba4dcb5f4372f6d6e67ce2adac74eac","impliedFormat":1},{"version":"2b9260f44a2e071450ae82c110f5dc8f330c9e5c3e85567ed97248330f2bf639","impliedFormat":1},{"version":"4f196e13684186bda6f5115fc4677a87cf84a0c9c4fc17b8f51e0984f3697b6d","impliedFormat":1},{"version":"61419f2c5822b28c1ea483258437c1faab87d00c6f84481aa22afb3380d8e9a4","impliedFormat":1},{"version":"64479aee03812264e421c0bf5104a953ca7b02740ba80090aead1330d0effe91","impliedFormat":1},{"version":"0521108c9f8ddb17654a0a54dae6ba9667c99eddccfd6af5748113e022d1c37a","impliedFormat":1},{"version":"c5570e504be103e255d80c60b56c367bf45d502ca52ee35c55dec882f6563b5c","impliedFormat":1},{"version":"ee764e6e9a7f2b987cc1a2c0a9afd7a8f4d5ebc4fdb66ad557a7f14a8c2bd320","impliedFormat":1},{"version":"0520b5093712c10c6ef23b5fea2f833bf5481771977112500045e5ea7e8e2b69","impliedFormat":1},{"version":"5c3cf26654cf762ac4d7fd7b83f09acfe08eef88d2d6983b9a5a423cb4004ca3","impliedFormat":1},{"version":"e60fa19cf7911c1623b891155d7eb6b7e844e9afdf5738e3b46f3b687730a2bd","impliedFormat":1},{"version":"b1fd72ff2bb0ba91bb588f3e5329f8fc884eb859794f1c4657a2bfa122ae54d0","impliedFormat":1},{"version":"6cf42a4f3cfec648545925d43afaa8bb364ac10a839ffed88249da109361b275","impliedFormat":1},{"version":"d7058e75920120b142a9d57be25562a3cd9a936269fd52908505f530105f2ec4","impliedFormat":1},{"version":"6df52b70d7f7702202f672541a5f4a424d478ee5be51a9d37b8ccbe1dbf3c0f2","impliedFormat":1},{"version":"0ca7f997e9a4d8985e842b7c882e521b6f63233c4086e9fe79dd7a9dc4742b5e","impliedFormat":1},{"version":"91046b5c6b55d3b194c81fd4df52f687736fad3095e9d103ead92bb64dc160ee","impliedFormat":1},{"version":"db5704fdad56c74dfc5941283c1182ed471bd17598209d3ac4a49faa72e43cfc","impliedFormat":1},{"version":"758e8e89559b02b81bc0f8fd395b17ad5aff75490c862cbe369bb1a3d1577c40","impliedFormat":1},{"version":"2ee64342c077b1868f1834c063f575063051edd6e2964257d34aad032d6b657c","impliedFormat":1},{"version":"6f6b4b3d670b6a5f0e24ea001c1b3d36453c539195e875687950a178f1730fa7","impliedFormat":1},{"version":"a472a1d3f25ce13a1d44911cd3983956ac040ce2018e155435ea34afb25f864c","impliedFormat":1},{"version":"b48b83a86dd9cfe36f8776b3ff52fcd45b0e043c0538dc4a4b149ba45fe367b9","impliedFormat":1},{"version":"792de5c062444bd2ee0413fb766e57e03cce7cdaebbfc52fc0c7c8e95069c96b","impliedFormat":1},{"version":"a79e3e81094c7a04a885bad9b049c519aace53300fb8a0fe4f26727cb5a746ce","impliedFormat":1},{"version":"93181bac0d90db185bb730c95214f6118ae997fe836a98a49664147fbcaf1988","impliedFormat":1},{"version":"8a4e89564d8ea66ad87ee3762e07540f9f0656a62043c910d819b4746fc429c5","impliedFormat":1},{"version":"b9011d99942889a0f95e120d06b698c628b0b6fdc3e6b7ecb459b97ed7d5bcc6","impliedFormat":1},{"version":"4d639cbbcc2f8f9ce6d55d5d503830d6c2556251df332dc5255d75af53c8a0e7","impliedFormat":1},{"version":"cdb48277f600ab5f429ecf1c5ea046683bc6b9f73f3deab9a100adac4b34969c","impliedFormat":1},{"version":"75be84956a29040a1afbe864c0a7a369dfdb739380072484eff153905ef867ee","impliedFormat":1},{"version":"b06b4adc2ae03331a92abd1b19af8eb91ec2bf8541747ee355887a167d53145e","impliedFormat":1},{"version":"c54166a85bd60f86d1ebb90ce0117c0ecb850b8a33b366691629fdf26f1bbbd8","impliedFormat":1},{"version":"0d417c15c5c635384d5f1819cc253a540fe786cc3fda32f6a2ae266671506a21","impliedFormat":1},{"version":"80f23f1d60fbed356f726b3b26f9d348dddbb34027926d10d59fad961e70a730","impliedFormat":1},{"version":"cb59317243a11379a101eb2f27b9df1022674c3df1df0727360a0a3f963f523b","impliedFormat":1},{"version":"cc20bb2227dd5de0aab0c8d697d1572f8000550e62c7bf5c92f212f657dd88c5","impliedFormat":1},{"version":"06b8a7d46195b6b3980e523ef59746702fd210b71681a83a5cf73799623621f9","impliedFormat":1},{"version":"860e4405959f646c101b8005a191298b2381af8f33716dc5f42097e4620608f8","impliedFormat":1},{"version":"f7e32adf714b8f25d3c1783473abec3f2e82d5724538d8dcf6f51baaaff1ca7a","impliedFormat":1},{"version":"d0da80c845999a16c24d0783033fb5366ada98df17867c98ad433ede05cd87fd","impliedFormat":1},{"version":"bfbf80f9cd4558af2d7b2006065340aaaced15947d590045253ded50aabb9bc5","impliedFormat":1},{"version":"fd9a991b51870325e46ebb0e6e18722d313f60cd8e596e645ec5ac15b96dbf4e","impliedFormat":1},{"version":"c3bd2b94e4298f81743d92945b80e9b56c1cdfb2bef43c149b7106a2491b1fc9","impliedFormat":1},{"version":"a246cce57f558f9ebaffd55c1e5673da44ea603b4da3b2b47eb88915d30a9181","impliedFormat":1},{"version":"d993eacc103c5a065227153c9aae8acea3a4322fe1a169ee7c70b77015bf0bb2","impliedFormat":1},{"version":"fc2b03d0c042aa1627406e753a26a1eaad01b3c496510a78016822ef8d456bb6","impliedFormat":1},{"version":"063c7ebbe756f0155a8b453f410ca6b76ffa1bbc1048735bcaf9c7c81a1ce35f","impliedFormat":1},{"version":"314e402cd481370d08f63051ae8b8c8e6370db5ee3b8820eeeaaf8d722a6dac6","impliedFormat":1},{"version":"9669075ac38ce36b638b290ba468233980d9f38bdc62f0519213b2fd3e2552ec","impliedFormat":1},{"version":"4d123de012c24e2f373925100be73d50517ac490f9ed3578ac82d0168bfbd303","impliedFormat":1},{"version":"656c9af789629aa36b39092bee3757034009620439d9a39912f587538033ce28","impliedFormat":1},{"version":"3ac3f4bdb8c0905d4c3035d6f7fb20118c21e8a17bee46d3735195b0c2a9f39f","impliedFormat":1},{"version":"1f453e6798ed29c86f703e9b41662640d4f2e61337007f27ac1c616f20093f69","impliedFormat":1},{"version":"af43b7871ff21c62bf1a54ec5c488e31a8d3408d5b51ff2e9f8581b6c55f2fc7","impliedFormat":1},{"version":"70550511d25cbb0b6a64dcac7fffc3c1397fd4cbeb6b23ccc7f9b794ab8a6954","impliedFormat":1},{"version":"af0fbf08386603a62f2a78c42d998c90353b1f1d22e05a384545f7accf881e0a","impliedFormat":1},{"version":"cefc20054d20b85b534206dbcedd509bb74f87f3d8bc45c58c7be3a76caa45e1","impliedFormat":1},{"version":"ad6eee4877d0f7e5244d34bc5026fd6e9cf8e66c5c79416b73f9f6ebf132f924","impliedFormat":1},{"version":"4888fd2bcfee9a0ce89d0df860d233e0cee8ee9c479b6bd5a5d5f9aae98342fe","impliedFormat":1},{"version":"f4749c102ced952aa6f40f0b579865429c4869f6d83df91000e98005476bee87","impliedFormat":1},{"version":"56654d2c5923598384e71cb808fac2818ca3f07dd23bb018988a39d5e64f268b","impliedFormat":1},{"version":"8b6719d3b9e65863da5390cb26994602c10a315aa16e7d70778a63fee6c4c079","impliedFormat":1},{"version":"05f56cd4b929977d18df8f3d08a4c929a2592ef5af083e79974b20a063f30940","impliedFormat":1},{"version":"547d3c406a21b30e2b78629ecc0b2ddaf652d9e0bdb2d59ceebce5612906df33","impliedFormat":1},{"version":"b3a4f9385279443c3a5568ec914a9492b59a723386161fd5ef0619d9f8982f97","impliedFormat":1},{"version":"3fe66aba4fbe0c3ba196a4f9ed2a776fe99dc4d1567a558fb11693e9fcc4e6ed","impliedFormat":1},{"version":"140eef237c7db06fc5adcb5df434ee21e81ee3a6fd57e1a75b8b3750aa2df2d8","impliedFormat":1},{"version":"0944ec553e4744efae790c68807a461720cff9f3977d4911ac0d918a17c9dd99","impliedFormat":1},{"version":"cb46b38d5e791acaa243bf342b8b5f8491639847463ac965b93896d4fb0af0d9","impliedFormat":1},{"version":"7c7d9e116fe51100ff766703e6b5e4424f51ad8977fe474ddd8d0959aa6de257","impliedFormat":1},{"version":"af70a2567e586be0083df3938b6a6792e6821363d8ef559ad8d721a33a5bcdaf","impliedFormat":1},{"version":"006cff3a8bcb92d77953f49a94cd7d5272fef4ab488b9052ef82b6a1260d870b","impliedFormat":1},{"version":"7d44bfdc8ee5e9af70738ff652c622ae3ad81815e63ab49bdc593d34cb3a68e5","impliedFormat":1},{"version":"339814517abd4dbc7b5f013dfd3b5e37ef0ea914a8bbe65413ecffd668792bc6","impliedFormat":1},{"version":"34d5bc0a6958967ec237c99f980155b5145b76e6eb927c9ffc57d8680326b5d8","impliedFormat":1},{"version":"9eae79b70c9d8288032cbe1b21d0941f6bd4f315e14786b2c1d10bccc634e897","impliedFormat":1},{"version":"18ce015ed308ea469b13b17f99ce53bbb97975855b2a09b86c052eefa4aa013a","impliedFormat":1},{"version":"5a931bc4106194e474be141e0bc1046629510dc95b9a0e4b02a3783847222965","impliedFormat":1},{"version":"5e5f371bf23d5ced2212a5ff56675aefbd0c9b3f4d4fdda1b6123ac6e28f058c","impliedFormat":1},{"version":"907c17ad5a05eecb29b42b36cc8fec6437be27cc4986bb3a218e4f74f606911c","impliedFormat":1},{"version":"ce60a562cd2a92f37a88f2ddd99a3abfbc5848d7baf38c48fb8d3243701fcb75","impliedFormat":1},{"version":"a726ad2d0a98bfffbe8bc1cd2d90b6d831638c0adc750ce73103a471eb9a891c","impliedFormat":1},{"version":"f44c0c8ce58d3dacac016607a1a90e5342d830ea84c48d2e571408087ae55894","impliedFormat":1},{"version":"75a315a098e630e734d9bc932d9841b64b30f7a349a20cf4717bf93044eff113","impliedFormat":1},{"version":"9131d95e32b3d4611d4046a613e022637348f6cebfe68230d4e81b691e4761a1","impliedFormat":1},{"version":"b03aa292cfdcd4edc3af00a7dbd71136dd067ec70a7536b655b82f4dd444e857","impliedFormat":1},{"version":"b6e2b0448ced813b8c207810d96551a26e7d7bb73255eea4b9701698f78846d6","impliedFormat":1},{"version":"8ae10cd85c1bd94d2f2d17c4cbd25c068a4b2471c70c2d96434239f97040747a","impliedFormat":1},{"version":"9ed5b799c50467b0c9f81ddf544b6bcda3e34d92076d6cab183c84511e45c39f","impliedFormat":1},{"version":"b4fa87cc1833839e51c49f20de71230e259c15b2c9c3e89e4814acc1d1ef10de","impliedFormat":1},{"version":"e90ac9e4ac0326faa1bc39f37af38ace0f9d4a655cd6d147713c653139cf4928","impliedFormat":1},{"version":"ea27110249d12e072956473a86fd1965df8e1be985f3b686b4e277afefdde584","impliedFormat":1},{"version":"8776a368617ce51129b74db7d55c3373dadcce5d0701e61d106e99998922a239","impliedFormat":1},{"version":"5666075052877fe2fdddd5b16de03168076cf0f03fbca5c1d4a3b8f43cba570c","impliedFormat":1},{"version":"9108ab5af05418f599ab48186193b1b07034c79a4a212a7f73535903ba4ca249","impliedFormat":1},{"version":"bb4e2cdcadf9c9e6ee2820af23cee6582d47c9c9c13b0dca1baaffe01fbbcb5f","impliedFormat":1},{"version":"6e30d0b5a1441d831d19fe02300ab3d83726abd5141cbcc0e2993fa0efd33db4","impliedFormat":1},{"version":"423f28126b2fc8d8d6fa558035309000a1297ed24473c595b7dec52e5c7ebae5","impliedFormat":1},{"version":"fb30734f82083d4790775dae393cd004924ebcbfde49849d9430bf0f0229dd16","impliedFormat":1},{"version":"2c92b04a7a4a1cd9501e1be338bf435738964130fb2ad5bd6c339ee41224ac4c","impliedFormat":1},{"version":"c5c5f0157b41833180419dacfbd2bcce78fb1a51c136bd4bcba5249864d8b9b5","impliedFormat":1},{"version":"02ae43d5bae42efcd5a00d3923e764895ce056bca005a9f4e623aa6b4797c8af","impliedFormat":1},{"version":"db6e01f17012a9d7b610ae764f94a1af850f5d98c9c826ad61747dca0fb800bd","impliedFormat":1},{"version":"8a44b424edee7bb17dc35a558cc15f92555f14a0441205613e0e50452ab3a602","impliedFormat":1},{"version":"24a00d0f98b799e6f628373249ece352b328089c3383b5606214357e9107e7d5","impliedFormat":1},{"version":"33637e3bc64edd2075d4071c55d60b32bdb0d243652977c66c964021b6fc8066","impliedFormat":1},{"version":"0f0ad9f14dedfdca37260931fac1edf0f6b951c629e84027255512f06a6ebc4c","impliedFormat":1},{"version":"16ad86c48bf950f5a480dc812b64225ca4a071827d3d18ffc5ec1ae176399e36","impliedFormat":1},{"version":"8cbf55a11ff59fd2b8e39a4aa08e25c5ddce46e3af0ed71fb51610607a13c505","impliedFormat":1},{"version":"d5bc4544938741f5daf8f3a339bfbf0d880da9e89e79f44a6383aaf056fe0159","impliedFormat":1},{"version":"97f9169882d393e6f303f570168ca86b5fe9aab556e9a43672dae7e6bb8e6495","impliedFormat":1},{"version":"7c9adb3fcd7851497818120b7e151465406e711d6a596a71b807f3a17853cb58","impliedFormat":1},{"version":"6752d402f9282dd6f6317c8c048aaaac27295739a166eed27e00391b358fed9a","impliedFormat":1},{"version":"9fd7466b77020847dbc9d2165829796bf7ea00895b2520ff3752ffdcff53564b","impliedFormat":1},{"version":"fbfc12d54a4488c2eb166ed63bab0fb34413e97069af273210cf39da5280c8d6","impliedFormat":1},{"version":"85a84240002b7cf577cec637167f0383409d086e3c4443852ca248fc6e16711e","impliedFormat":1},{"version":"84794e3abd045880e0fadcf062b648faf982aa80cfc56d28d80120e298178626","impliedFormat":1},{"version":"053d8b827286a16a669a36ffc8ccc8acdf8cc154c096610aa12348b8c493c7b8","impliedFormat":1},{"version":"3cce4ce031710970fe12d4f7834375f5fd455aa129af4c11eb787935923ff551","impliedFormat":1},{"version":"8f62cbd3afbd6a07bb8c934294b6bfbe437021b89e53a4da7de2648ecfc7af25","impliedFormat":1},{"version":"62c3621d34fb2567c17a2c4b89914ebefbfbd1b1b875b070391a7d4f722e55dc","impliedFormat":1},{"version":"c05ac811542e0b59cb9c2e8f60e983461f0b0e39cea93e320fad447ff8e474f3","impliedFormat":1},{"version":"8e7a5b8f867b99cc8763c0b024068fb58e09f7da2c4810c12833e1ca6eb11c4f","impliedFormat":1},{"version":"132351cbd8437a463757d3510258d0fa98fd3ebef336f56d6f359cf3e177a3ce","impliedFormat":1},{"version":"df877050b04c29b9f8409aa10278d586825f511f0841d1ec41b6554f8362092b","impliedFormat":1},{"version":"33d1888c3c27d3180b7fd20bac84e97ecad94b49830d5dd306f9e770213027d1","impliedFormat":1},{"version":"ee942c58036a0de88505ffd7c129f86125b783888288c2389330168677d6347f","impliedFormat":1},{"version":"a3f317d500c30ea56d41501632cdcc376dae6d24770563a5e59c039e1c2a08ec","impliedFormat":1},{"version":"eb21ddc3a8136a12e69176531197def71dc28ffaf357b74d4bf83407bd845991","impliedFormat":1},{"version":"0c1651a159995dfa784c57b4ea9944f16bdf8d924ed2d8b3db5c25d25749a343","impliedFormat":1},{"version":"aaa13958e03409d72e179b5d7f6ec5c6cc666b7be14773ae7b6b5ee4921e52db","impliedFormat":1},{"version":"0a86e049843ad02977a94bb9cdfec287a6c5a0a4b6b5391a6648b1a122072c5a","impliedFormat":1},{"version":"40f06693e2e3e58526b713c937895c02e113552dc8ba81ecd49cdd9596567ddb","impliedFormat":1},{"version":"4ed5e1992aedb174fb8f5aa8796aa6d4dcb8bd819b4af1b162a222b680a37fa0","impliedFormat":1},{"version":"d7f4bd46a8b97232ea6f8c28012b8d2b995e55e729d11405f159d3e00c51420a","impliedFormat":1},{"version":"d604d413aff031f4bfbdae1560e54ebf503d374464d76d50a2c6ded4df525712","impliedFormat":1},{"version":"e4f4f9cf1e3ac9fd91ada072e4d428ecbf0aa6dc57138fb797b8a0ca3a1d521c","impliedFormat":1},{"version":"12bfd290936824373edda13f48a4094adee93239b9a73432db603127881a300d","impliedFormat":1},{"version":"340ceb3ea308f8e98264988a663640e567c553b8d6dc7d5e43a8f3b64f780374","impliedFormat":1},{"version":"c5a769564e530fba3ec696d0a5cff1709b9095a0bdf5b0826d940d2fc9786413","impliedFormat":1},{"version":"7124ef724c3fc833a17896f2d994c368230a8d4b235baed39aa8037db31de54f","impliedFormat":1},{"version":"5de1c0759a76e7710f76899dcae601386424eab11fb2efaf190f2b0f09c3d3d3","impliedFormat":1},{"version":"9c5ee8f7e581f045b6be979f062a61bf076d362bf89c7f966b993a23424e8b0d","impliedFormat":1},{"version":"1a11df987948a86aa1ec4867907c59bdf431f13ed2270444bf47f788a5c7f92d","impliedFormat":1},{"version":"8018dd2e95e7ce6e613ddd81672a54532614dc745520a2f9e3860ff7fb1be0ca","impliedFormat":1},{"version":"b756781cd40d465da57d1fc6a442c34ae61fe8c802d752aace24f6a43fedacee","impliedFormat":1},{"version":"0fe76167c87289ea094e01616dcbab795c11b56bad23e1ef8aba9aa37e93432a","impliedFormat":1},{"version":"3a45029dba46b1f091e8dc4d784e7be970e209cd7d4ff02bd15270a98a9ba24b","impliedFormat":1},{"version":"032c1581f921f8874cf42966f27fd04afcabbb7878fa708a8251cac5415a2a06","impliedFormat":1},{"version":"69c68ed9652842ce4b8e495d63d2cd425862104c9fb7661f72e7aa8a9ef836f8","impliedFormat":1},{"version":"0e704ee6e9fd8b6a5a7167886f4d8915f4bc22ed79f19cb7b32bd28458f50643","impliedFormat":1},{"version":"06f62a14599a68bcde148d1efd60c2e52e8fa540cc7dcfa4477af132bb3de271","impliedFormat":1},{"version":"904a96f84b1bcee9a7f0f258d17f8692e6652a0390566515fe6741a5c6db8c1c","impliedFormat":1},{"version":"11f19ce32d21222419cecab448fa335017ebebf4f9e5457c4fa9df42fa2dcca7","impliedFormat":1},{"version":"2e8ee2cbb5e9159764e2189cf5547aebd0e6b0d9a64d479397bb051cd1991744","impliedFormat":1},{"version":"1b0471d75f5adb7f545c1a97c02a0f825851b95fe6e069ac6ecaa461b8bb321d","impliedFormat":1},{"version":"1d157c31a02b1e5cca9bc495b3d8d39f4b42b409da79f863fb953fbe3c7d4884","impliedFormat":1},{"version":"07baaceaec03d88a4b78cb0651b25f1ae0322ac1aa0b555ae3749a79a41cba86","impliedFormat":1},{"version":"619a132f634b4ebe5b4b4179ea5870f62f2cb09916a25957bff17b408de8b56d","impliedFormat":1},{"version":"f60fa446a397eb1aead9c4e568faf2df8068b4d0306ebc075fb4be16ed26b741","impliedFormat":1},{"version":"f3cb784be4d9e91f966a0b5052a098d9b53b0af0d341f690585b0cc05c6ca412","impliedFormat":1},{"version":"350f63439f8fe2e06c97368ddc7fb6d6c676d54f59520966f7dbbe6a4586014e","impliedFormat":1},{"version":"eba613b9b357ac8c50a925fa31dc7e65ff3b95a07efbaa684b624f143d8d34ba","impliedFormat":1},{"version":"45b74185005ed45bec3f07cac6e4d68eaf02ead9ff5a66721679fb28020e5e7c","impliedFormat":1},{"version":"0f6199602df09bdb12b95b5434f5d7474b1490d2cd8cc036364ab3ba6fd24263","impliedFormat":1},{"version":"c8ca7fd9ec7a3ec82185bfc8213e4a7f63ae748fd6fced931741d23ef4ea3c0f","impliedFormat":1},{"version":"5c6a8a3c2a8d059f0592d4eab59b062210a1c871117968b10797dee36d991ef7","impliedFormat":1},{"version":"ad77fd25ece8e09247040826a777dc181f974d28257c9cd5acb4921b51967bd8","impliedFormat":1},{"version":"08323a8971cb5b2632b532cba1636ad4ca0d76f9f7d0b8d1a0c706fdf5c77b45","impliedFormat":1},{"version":"06fc6fbc8eb2135401cf5adce87655790891ca22ad4f97dfccd73c8cf8d8e6b5","impliedFormat":99},{"version":"1cce0c01dd7e255961851cdb9aa3d5164ec5f0e7f0fefc61e28f29afedda374f","impliedFormat":99},{"version":"7778598dfac1b1f51b383105034e14a0e95bc7b2538e0c562d5d315e7d576b76","impliedFormat":99},{"version":"b14409570c33921eb797282bb7f9c614ccc6008bf3800ba184e950cdfc54ab5c","impliedFormat":99},{"version":"2f0357257a651cc1b14e77b57a63c7b9e4e10ec2bb57e5fdccf83be0efb35280","impliedFormat":99},{"version":"866e63a72a9e85ed1ec74eaebf977be1483f44aa941bcae2ba9b9e3b39ca4395","impliedFormat":99},{"version":"6865d0d503a5ad6775339f6b5dcfa021d72d2567027943b52679222411ad2501","impliedFormat":99},{"version":"dc2be4768bcf96e5d5540ed06fdfbddb2ee210227556ea7b8114ad09d06d35a5","impliedFormat":99},{"version":"e86813f0b7a1ada681045a56323df84077c577ef6351461d4fff4c4afdf79302","impliedFormat":99},{"version":"b3ace759b8242cc742efb6e54460ed9b8ceb9e56ce6a9f9d5f7debe73ed4e416","impliedFormat":99},{"version":"1c4d715c5b7545acecd99744477faa8265ca3772b82c3fa5d77bfc8a27549c7e","impliedFormat":99},{"version":"8f92dbdd3bbc8620e798d221cb7c954f8e24e2eed31749dfdb5654379b031c26","impliedFormat":99},{"version":"f30bfef33d69e4d0837e9e0bbf5ea14ca148d73086dc95a207337894fde45c6b","impliedFormat":99},{"version":"82230238479c48046653e40a6916e3c820b947cb9e28b58384bc4e4cea6a9e92","impliedFormat":99},{"version":"3a6941ff3ea7b78017f9a593d0fd416feb45defa577825751c01004620b507d3","impliedFormat":99},{"version":"481c38439b932ef9e87e68139f6d03b0712bc6fc2880e909886374452a4169b5","impliedFormat":99},{"version":"64054d6374f7b8734304272e837aa0edcf4cfa2949fa5810971f747a0f0d9e9e","impliedFormat":99},{"version":"267498893325497596ff0d99bfdb5030ab4217c43801221d2f2b5eb5734e8244","impliedFormat":99},{"version":"d2ec89fb0934a47f277d5c836b47c1f692767511e3f2c38d00213c8ec4723437","impliedFormat":99},{"version":"475e411f48f74c14b1f6e50cc244387a5cc8ce52340dddfae897c96e03f86527","impliedFormat":99},{"version":"c1022a2b86fadc3f994589c09331bdb3461966fb87ebb3e28c778159a300044e","impliedFormat":99},{"version":"f3d8c757e148ad968f0d98697987db363070abada5f503da3c06aefd9d4248c1","impliedFormat":1},{"version":"492e71f8f8f44a968be333ea1bd4e761b020216a380b5b3b213b06a9aecdfbf4","impliedFormat":1},{"version":"6eb639ffa89a206d4eb9e68270ba781caede9fe44aa5dc8f73600a2f6b166715","impliedFormat":1},{"version":"b3a24e1c22dd4fde2ce413fb8244e5fa8773ffca88e8173c780845c9856aef73","impliedFormat":1},{"version":"c130f9616a960edc892aa0eb7a8a59f33e662c561474ed092c43a955cdb91dab","impliedFormat":1}],"root":[222,223,809,[877,914],[922,940]],"options":{"composite":true,"declaration":true,"declarationMap":true,"esModuleInterop":true,"module":199,"noEmitOnError":false,"skipLibCheck":true,"sourceMap":true,"strict":true,"target":9},"referencedMap":[[918,1],[919,2],[917,3],[920,4],[921,5],[915,6],[916,3],[210,7],[218,8],[215,9],[221,10],[209,6],[206,11],[216,12],[219,13],[220,14],[195,15],[212,16],[211,6],[208,6],[217,11],[207,17],[214,18],[395,19],[396,20],[391,21],[392,19],[393,22],[394,19],[386,11],[388,23],[389,24],[390,25],[387,26],[87,27],[90,28],[96,29],[99,30],[120,31],[98,32],[79,11],[80,33],[81,34],[84,11],[82,11],[83,11],[121,35],[86,27],[85,11],[122,36],[89,28],[88,11],[126,37],[123,38],[93,39],[95,40],[92,41],[94,42],[91,39],[124,43],[97,27],[125,44],[100,45],[119,46],[116,47],[118,48],[103,49],[110,50],[112,51],[114,52],[113,53],[105,54],[102,47],[106,11],[117,55],[107,56],[104,11],[115,11],[101,11],[108,57],[109,11],[111,58],[770,59],[769,60],[498,61],[499,62],[494,63],[495,61],[496,64],[497,61],[489,11],[491,65],[492,24],[493,66],[490,67],[502,68],[511,69],[503,70],[508,71],[509,71],[507,72],[506,73],[504,74],[505,75],[500,76],[501,70],[510,71],[224,24],[233,24],[225,11],[226,24],[228,77],[231,11],[229,78],[230,24],[227,24],[232,11],[361,79],[360,80],[343,81],[235,82],[236,11],[237,11],[342,83],[339,84],[239,85],[340,11],[341,86],[344,24],[238,11],[346,24],[347,24],[348,24],[349,24],[350,24],[351,24],[352,24],[345,24],[358,11],[234,24],[353,11],[354,11],[355,11],[356,11],[357,78],[359,11],[808,87],[807,88],[806,89],[805,90],[779,91],[514,92],[515,93],[513,94],[512,69],[579,95],[578,96],[577,97],[516,69],[583,98],[581,86],[584,99],[582,100],[580,69],[590,101],[588,102],[589,11],[587,103],[586,62],[585,69],[594,104],[593,105],[592,106],[591,69],[595,11],[600,107],[599,108],[597,109],[598,69],[604,110],[603,111],[602,112],[601,69],[608,113],[607,114],[606,112],[605,69],[612,115],[611,116],[610,112],[609,69],[617,11],[614,11],[618,117],[616,118],[615,119],[613,69],[619,11],[623,120],[622,121],[621,106],[620,69],[627,122],[626,123],[625,124],[624,69],[630,125],[629,112],[628,69],[634,126],[633,127],[632,106],[631,69],[638,128],[637,129],[636,112],[635,69],[641,11],[642,130],[640,112],[639,69],[645,131],[646,132],[644,133],[643,69],[650,134],[649,135],[648,94],[647,69],[654,136],[653,137],[652,94],[651,69],[658,138],[657,139],[656,112],[655,69],[662,11],[663,140],[661,141],[660,106],[659,69],[666,142],[665,112],[664,69],[671,143],[670,144],[669,112],[667,69],[675,145],[674,146],[673,106],[672,69],[679,147],[678,148],[677,106],[676,69],[687,149],[686,150],[685,112],[684,69],[683,151],[682,152],[681,106],[680,69],[690,11],[691,153],[689,112],[688,69],[695,154],[693,112],[694,11],[692,69],[705,11],[706,155],[704,156],[703,157],[696,69],[710,158],[709,159],[708,106],[707,69],[718,160],[717,161],[716,94],[715,69],[714,162],[713,163],[712,106],[711,69],[722,11],[723,164],[721,165],[720,106],[719,69],[726,11],[727,166],[725,112],[724,69],[731,11],[732,167],[730,168],[729,106],[728,69],[736,169],[735,170],[734,112],[733,69],[740,171],[738,94],[739,172],[737,69],[745,173],[744,174],[743,103],[742,62],[741,69],[475,175],[485,176],[477,177],[482,178],[483,178],[481,179],[480,180],[478,181],[479,75],[473,182],[474,177],[484,178],[782,11],[801,11],[802,183],[800,11],[780,11],[781,184],[804,185],[797,186],[803,187],[798,188],[799,11],[793,11],[784,189],[783,11],[796,190],[795,191],[792,192],[788,193],[791,194],[786,193],[794,191],[785,195],[790,196],[787,193],[789,91],[746,197],[767,198],[762,199],[764,199],[763,199],[765,199],[766,200],[761,201],[753,199],[754,202],[760,203],[755,199],[756,202],[757,199],[758,199],[759,202],[768,204],[747,197],[752,205],[750,11],[751,206],[749,207],[748,208],[407,209],[404,210],[406,210],[403,211],[402,212],[397,213],[405,214],[411,215],[398,216],[401,217],[399,218],[400,219],[410,220],[408,221],[409,222],[385,223],[362,224],[383,225],[378,226],[380,226],[379,226],[381,226],[382,227],[377,228],[369,226],[370,229],[376,230],[371,226],[372,229],[373,226],[374,226],[375,229],[384,231],[363,224],[368,232],[366,11],[367,233],[365,234],[364,235],[420,236],[422,11],[423,11],[424,237],[421,236],[427,238],[425,236],[426,236],[419,239],[432,240],[417,11],[436,241],[440,242],[439,243],[431,244],[433,245],[434,246],[437,247],[438,248],[442,249],[430,250],[441,251],[435,24],[418,252],[428,253],[413,24],[415,254],[416,255],[414,11],[429,256],[412,231],[488,257],[487,258],[486,259],[471,231],[472,91],[861,260],[863,261],[868,262],[869,262],[871,263],[854,264],[870,265],[860,266],[857,11],[876,267],[867,268],[864,269],[866,270],[865,271],[858,24],[872,272],[873,272],[874,273],[875,272],[855,274],[856,275],[853,24],[862,276],[859,277],[814,24],[823,24],[815,11],[816,24],[818,278],[821,11],[819,279],[820,24],[817,24],[822,11],[852,280],[851,281],[834,282],[825,283],[826,11],[827,11],[833,284],[830,84],[829,285],[831,11],[832,86],[835,24],[828,11],[837,24],[838,24],[839,24],[840,24],[841,24],[842,24],[843,24],[836,24],[849,11],[824,24],[844,11],[845,11],[846,11],[847,11],[848,279],[850,11],[468,286],[470,287],[469,288],[443,231],[452,289],[454,290],[459,291],[460,291],[462,292],[447,293],[461,294],[451,295],[444,11],[467,91],[458,296],[455,297],[457,298],[456,299],[445,24],[463,300],[464,300],[465,301],[466,300],[448,302],[449,303],[446,24],[453,304],[450,305],[810,11],[812,11],[811,11],[813,306],[778,307],[774,308],[773,11],[775,11],[777,11],[776,11],[772,309],[771,11],[517,11],[518,11],[519,11],[576,310],[520,311],[565,312],[522,313],[521,314],[523,311],[524,311],[526,315],[525,311],[527,316],[528,316],[529,311],[531,317],[532,311],[533,317],[534,311],[536,311],[537,311],[538,311],[539,318],[535,311],[540,11],[541,319],[542,319],[543,319],[544,319],[545,319],[554,320],[546,319],[547,319],[548,319],[549,319],[551,319],[550,319],[552,319],[553,319],[555,311],[556,311],[530,311],[557,317],[559,321],[558,311],[560,311],[561,311],[562,322],[564,311],[563,311],[566,311],[568,311],[569,323],[567,311],[570,311],[571,311],[572,311],[573,311],[574,311],[575,311],[941,324],[943,325],[596,326],[942,11],[944,11],[945,11],[1156,327],[1136,328],[1138,329],[1137,328],[1140,330],[1142,331],[1143,332],[1144,333],[1145,331],[1146,332],[1147,331],[1148,334],[1149,332],[1150,331],[1151,335],[1152,328],[1153,328],[1154,336],[1141,337],[1155,338],[1139,338],[1157,11],[1158,339],[668,324],[1159,340],[285,341],[286,341],[287,342],[245,343],[288,344],[289,345],[290,346],[240,11],[243,347],[241,11],[242,11],[291,348],[292,349],[293,350],[294,351],[295,352],[296,353],[297,353],[299,354],[298,355],[300,356],[301,357],[302,358],[284,359],[244,11],[303,360],[304,361],[305,362],[338,363],[306,364],[307,365],[308,366],[309,367],[310,75],[311,368],[312,369],[313,370],[314,371],[315,372],[316,372],[317,373],[318,11],[319,11],[320,374],[322,375],[321,376],[323,377],[324,378],[325,379],[326,380],[327,381],[328,382],[329,383],[330,384],[331,385],[332,386],[333,387],[334,388],[335,389],[336,390],[337,391],[1160,392],[702,393],[476,11],[1161,394],[1135,395],[246,11],[213,11],[701,396],[698,86],[700,397],[699,11],[697,11],[1134,398],[1107,11],[1085,399],[1083,399],[1133,400],[1098,401],[1097,401],[998,402],[949,403],[1105,402],[1106,402],[1108,404],[1109,402],[1110,405],[1009,406],[1111,402],[1082,402],[1112,402],[1113,407],[1114,402],[1115,401],[1116,408],[1117,402],[1118,402],[1119,402],[1120,402],[1121,401],[1122,402],[1123,402],[1124,402],[1125,402],[1126,409],[1127,402],[1128,402],[1129,402],[1130,402],[1131,402],[948,400],[951,405],[952,405],[953,405],[954,405],[955,405],[956,405],[957,405],[958,402],[960,410],[961,405],[959,405],[962,405],[963,405],[964,405],[965,405],[966,405],[967,405],[968,402],[969,405],[970,405],[971,405],[972,405],[973,405],[974,402],[975,405],[976,405],[977,405],[978,405],[979,405],[980,405],[981,402],[983,411],[982,405],[984,405],[985,405],[986,405],[987,405],[988,409],[989,402],[990,402],[1004,412],[992,413],[993,405],[994,405],[995,402],[996,405],[997,405],[999,414],[1000,405],[1001,405],[1002,405],[1003,405],[1005,405],[1006,405],[1007,405],[1008,405],[1010,415],[1011,405],[1012,405],[1013,405],[1014,402],[1015,405],[1016,416],[1017,416],[1018,416],[1019,402],[1020,405],[1021,405],[1022,405],[1027,405],[1023,405],[1024,402],[1025,405],[1026,402],[1028,405],[1029,405],[1030,405],[1031,405],[1032,405],[1033,405],[1034,402],[1035,405],[1036,405],[1037,405],[1038,405],[1039,405],[1040,405],[1041,405],[1042,405],[1043,405],[1044,405],[1045,405],[1046,405],[1047,405],[1048,405],[1049,405],[1050,405],[1051,417],[1052,405],[1053,405],[1054,405],[1055,405],[1056,405],[1057,405],[1058,402],[1059,402],[1060,402],[1061,402],[1062,402],[1063,405],[1064,405],[1065,405],[1066,405],[1084,418],[1132,402],[1069,419],[1068,420],[1092,421],[1091,422],[1087,423],[1086,422],[1088,424],[1077,425],[1075,426],[1090,427],[1089,424],[1076,11],[1078,428],[991,429],[947,430],[946,405],[1081,11],[1073,431],[1074,432],[1071,11],[1072,433],[1070,405],[1079,434],[950,435],[1099,11],[1100,11],[1093,11],[1096,401],[1095,11],[1101,11],[1102,11],[1094,436],[1103,11],[1104,11],[1067,437],[1080,438],[77,11],[78,11],[14,11],[13,11],[2,11],[15,11],[16,11],[17,11],[18,11],[19,11],[20,11],[21,11],[22,11],[3,11],[23,11],[24,11],[4,11],[25,11],[29,11],[26,11],[27,11],[28,11],[30,11],[31,11],[32,11],[5,11],[33,11],[34,11],[35,11],[36,11],[6,11],[40,11],[37,11],[38,11],[39,11],[41,11],[7,11],[42,11],[47,11],[48,11],[43,11],[44,11],[45,11],[46,11],[8,11],[52,11],[49,11],[50,11],[51,11],[53,11],[9,11],[54,11],[55,11],[56,11],[58,11],[57,11],[59,11],[60,11],[10,11],[61,11],[62,11],[63,11],[11,11],[64,11],[65,11],[66,11],[67,11],[68,11],[1,11],[69,11],[70,11],[12,11],[74,11],[72,11],[76,11],[71,11],[75,11],[73,11],[262,439],[272,440],[261,439],[282,441],[253,442],[252,443],[281,86],[275,444],[280,445],[255,446],[269,447],[254,448],[278,449],[250,450],[249,86],[279,451],[251,452],[256,453],[257,11],[260,453],[247,11],[283,454],[273,455],[264,456],[265,457],[267,458],[263,459],[266,460],[276,86],[258,461],[259,462],[268,463],[248,464],[271,455],[270,453],[274,11],[277,465],[140,466],[131,467],[138,468],[133,11],[134,11],[132,469],[135,470],[127,11],[128,11],[139,471],[130,472],[136,11],[137,473],[129,474],[199,475],[202,476],[200,476],[196,475],[203,477],[204,478],[201,476],[197,479],[198,480],[191,481],[145,482],[147,483],[189,11],[146,484],[190,485],[194,486],[192,11],[148,482],[149,11],[188,487],[144,488],[141,11],[193,489],[142,490],[143,11],[205,491],[150,492],[151,492],[152,492],[153,492],[154,492],[155,492],[156,492],[157,492],[158,492],[159,492],[161,492],[160,492],[162,492],[163,492],[164,492],[187,493],[165,492],[166,492],[167,492],[168,492],[169,492],[170,492],[171,492],[172,492],[173,492],[174,492],[175,492],[176,492],[177,492],[178,492],[179,492],[180,492],[181,492],[182,492],[183,492],[184,492],[185,492],[186,492],[931,494],[938,495],[932,6],[933,496],[934,496],[936,497],[935,496],[906,498],[908,499],[907,500],[910,501],[885,11],[879,502],[222,503],[880,504],[881,502],[882,505],[883,504],[884,502],[886,506],[888,507],[887,504],[890,502],[891,508],[892,502],[893,502],[894,509],[895,504],[896,502],[897,510],[878,511],[898,504],[899,502],[900,512],[937,513],[901,504],[902,502],[903,514],[904,502],[905,502],[911,515],[912,504],[913,502],[914,516],[924,504],[925,502],[926,517],[922,502],[923,518],[930,519],[939,520],[927,502],[928,502],[929,521],[889,11],[909,522],[877,523],[223,24],[940,524],[809,525]],"semanticDiagnosticsPerFile":[[222,[{"start":1987,"length":99,"messageText":"Type instantiation is excessively deep and possibly infinite.","category":1,"code":2589}]],[938,[{"start":3622,"length":586,"messageText":"Type instantiation is excessively deep and possibly infinite.","category":1,"code":2589}]]],"latestChangedDtsFile":"./src/utils/versionUtils-cjs.d.cts","version":"5.8.3"} \ No newline at end of file From 2b6b1cb4db7eb3712535bd79d0dad52e62d8571f Mon Sep 17 00:00:00 2001 From: Matthew Podwysocki Date: Wed, 7 Jan 2026 11:40:48 -0500 Subject: [PATCH 5/8] Add 8 offline geospatial tools using Turf.js MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implement fundamental geospatial calculation tools that work completely offline without requiring Mapbox API calls: - point_in_polygon_tool: Test if a point is inside a polygon - bearing_tool: Calculate compass direction between coordinates - midpoint_tool: Find geographic midpoint between two points - centroid_tool: Calculate center point of polygons - area_tool: Calculate polygon area in various units (meters, km, acres, etc) - bbox_tool: Calculate bounding box of any geometry - buffer_tool: Create buffer zones around geometries - simplify_tool: Reduce vertex count while preserving shape All tools: - Extend BaseTool (not MapboxApiBasedTool) for offline operation - Use Turf.js (@turf/turf) for geospatial calculations - Include OpenTelemetry tracing - Have proper annotations (openWorldHint: false) - Use coordinate objects for inputs to avoid JSON schema issues Updated test annotations to include all offline tools in exclusion list. All 457 tests passing. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 --- src/tools/area-tool/AreaTool.input.schema.ts | 37 +++++ src/tools/area-tool/AreaTool.output.schema.ts | 17 +++ src/tools/area-tool/AreaTool.ts | 122 ++++++++++++++++ .../bearing-tool/BearingTool.input.schema.ts | 27 ++++ .../bearing-tool/BearingTool.output.schema.ts | 24 +++ src/tools/bearing-tool/BearingTool.ts | 107 ++++++++++++++ .../BoundingBoxTool.input.schema.ts | 34 +++++ .../BoundingBoxTool.output.schema.ts | 18 +++ .../bounding-box-tool/BoundingBoxTool.ts | 131 +++++++++++++++++ .../buffer-tool/BufferTool.input.schema.ts | 36 +++++ .../buffer-tool/BufferTool.output.schema.ts | 20 +++ src/tools/buffer-tool/BufferTool.ts | 124 ++++++++++++++++ .../CentroidTool.input.schema.ts | 32 ++++ .../CentroidTool.output.schema.ts | 19 +++ src/tools/centroid-tool/CentroidTool.ts | 103 +++++++++++++ .../MidpointTool.input.schema.ts | 27 ++++ .../MidpointTool.output.schema.ts | 27 ++++ src/tools/midpoint-tool/MidpointTool.ts | 101 +++++++++++++ .../PointInPolygonTool.input.schema.ts | 36 +++++ .../PointInPolygonTool.output.schema.ts | 22 +++ .../PointInPolygonTool.ts | 104 +++++++++++++ .../SimplifyTool.input.schema.ts | 43 ++++++ .../SimplifyTool.output.schema.ts | 26 ++++ src/tools/simplify-tool/SimplifyTool.ts | 137 ++++++++++++++++++ src/tools/toolRegistry.ts | 16 ++ test/tools/annotations.test.ts | 26 +++- 26 files changed, 1414 insertions(+), 2 deletions(-) create mode 100644 src/tools/area-tool/AreaTool.input.schema.ts create mode 100644 src/tools/area-tool/AreaTool.output.schema.ts create mode 100644 src/tools/area-tool/AreaTool.ts create mode 100644 src/tools/bearing-tool/BearingTool.input.schema.ts create mode 100644 src/tools/bearing-tool/BearingTool.output.schema.ts create mode 100644 src/tools/bearing-tool/BearingTool.ts create mode 100644 src/tools/bounding-box-tool/BoundingBoxTool.input.schema.ts create mode 100644 src/tools/bounding-box-tool/BoundingBoxTool.output.schema.ts create mode 100644 src/tools/bounding-box-tool/BoundingBoxTool.ts create mode 100644 src/tools/buffer-tool/BufferTool.input.schema.ts create mode 100644 src/tools/buffer-tool/BufferTool.output.schema.ts create mode 100644 src/tools/buffer-tool/BufferTool.ts create mode 100644 src/tools/centroid-tool/CentroidTool.input.schema.ts create mode 100644 src/tools/centroid-tool/CentroidTool.output.schema.ts create mode 100644 src/tools/centroid-tool/CentroidTool.ts create mode 100644 src/tools/midpoint-tool/MidpointTool.input.schema.ts create mode 100644 src/tools/midpoint-tool/MidpointTool.output.schema.ts create mode 100644 src/tools/midpoint-tool/MidpointTool.ts create mode 100644 src/tools/point-in-polygon-tool/PointInPolygonTool.input.schema.ts create mode 100644 src/tools/point-in-polygon-tool/PointInPolygonTool.output.schema.ts create mode 100644 src/tools/point-in-polygon-tool/PointInPolygonTool.ts create mode 100644 src/tools/simplify-tool/SimplifyTool.input.schema.ts create mode 100644 src/tools/simplify-tool/SimplifyTool.output.schema.ts create mode 100644 src/tools/simplify-tool/SimplifyTool.ts diff --git a/src/tools/area-tool/AreaTool.input.schema.ts b/src/tools/area-tool/AreaTool.input.schema.ts new file mode 100644 index 0000000..d136032 --- /dev/null +++ b/src/tools/area-tool/AreaTool.input.schema.ts @@ -0,0 +1,37 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; + +const CoordinateSchema = z + .array(z.number()) + .length(2) + .describe('Coordinate as [longitude, latitude]'); + +/** + * Input schema for AreaTool + */ +export const AreaInputSchema = z.object({ + geometry: z + .union([ + // Polygon + z.array(z.array(CoordinateSchema)).min(1), + // MultiPolygon + z.array(z.array(z.array(CoordinateSchema))).min(1) + ]) + .describe( + 'Polygon or MultiPolygon coordinates. ' + + 'Polygon: array of rings (first is outer, rest are holes). ' + + 'MultiPolygon: array of polygons.' + ), + units: z + .enum(['meters', 'kilometers', 'feet', 'miles', 'acres', 'hectares']) + .optional() + .default('meters') + .describe('Unit of measurement for area') +}); + +/** + * Type inference for AreaInput + */ +export type AreaInput = z.infer; diff --git a/src/tools/area-tool/AreaTool.output.schema.ts b/src/tools/area-tool/AreaTool.output.schema.ts new file mode 100644 index 0000000..1bdcf4e --- /dev/null +++ b/src/tools/area-tool/AreaTool.output.schema.ts @@ -0,0 +1,17 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Output schema for AreaTool + */ +export const AreaOutputSchema = z.object({ + area: z.number().describe('Calculated area'), + units: z.string().describe('Unit of measurement') +}); + +/** + * Type inference for AreaOutput + */ +export type AreaOutput = z.infer; diff --git a/src/tools/area-tool/AreaTool.ts b/src/tools/area-tool/AreaTool.ts new file mode 100644 index 0000000..1f57fb7 --- /dev/null +++ b/src/tools/area-tool/AreaTool.ts @@ -0,0 +1,122 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { area as turfArea, polygon, multiPolygon } from '@turf/turf'; +import { context, SpanStatusCode, trace } from '@opentelemetry/api'; +import { createLocalToolExecutionContext } from '../../utils/tracing.js'; +import { BaseTool } from '../BaseTool.js'; +import { AreaInputSchema } from './AreaTool.input.schema.js'; +import { AreaOutputSchema, type AreaOutput } from './AreaTool.output.schema.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; + +/** + * AreaTool - Calculate the area of a polygon or multipolygon + */ +export class AreaTool extends BaseTool< + typeof AreaInputSchema, + typeof AreaOutputSchema +> { + readonly name = 'area_tool'; + readonly description = + 'Calculate the area of a polygon or multipolygon. ' + + 'Supports various units including square meters, kilometers, acres, and hectares. ' + + 'Works offline without API calls.'; + + readonly annotations = { + title: 'Calculate Area', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: false + }; + + constructor() { + super({ + inputSchema: AreaInputSchema, + outputSchema: AreaOutputSchema + }); + } + + async run(rawInput: unknown): Promise { + const toolContext = createLocalToolExecutionContext(this.name, 0); + return await context.with( + trace.setSpan(context.active(), toolContext.span), + async () => { + try { + const input = AreaInputSchema.parse(rawInput); + + // Determine if it's a polygon or multipolygon based on depth + const isMultiPolygon = + Array.isArray(input.geometry[0]) && + Array.isArray(input.geometry[0][0]) && + Array.isArray(input.geometry[0][0][0]); + + const geom = isMultiPolygon + ? multiPolygon(input.geometry as number[][][][]) + : polygon(input.geometry as number[][][]); + + // Calculate area in square meters first + const areaInSquareMeters = turfArea(geom); + + // Convert to requested units + let area: number; + switch (input.units) { + case 'meters': + area = areaInSquareMeters; + break; + case 'kilometers': + area = areaInSquareMeters / 1000000; + break; + case 'feet': + area = areaInSquareMeters * 10.7639; + break; + case 'miles': + area = areaInSquareMeters / 2589988.11; + break; + case 'acres': + area = areaInSquareMeters / 4046.86; + break; + case 'hectares': + area = areaInSquareMeters / 10000; + break; + default: + area = areaInSquareMeters; + } + + const result: AreaOutput = { + area: Math.round(area * 1000) / 1000, + units: input.units + }; + + const validatedResult = this.validateOutput(result) as AreaOutput; + + const text = `Area: ${validatedResult.area} square ${validatedResult.units}`; + + toolContext.span.setStatus({ code: SpanStatusCode.OK }); + toolContext.span.end(); + + return { + content: [{ type: 'text' as const, text }], + structuredContent: validatedResult, + isError: false + }; + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : String(error); + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); + toolContext.span.end(); + this.log('error', `${this.name}: ${errorMessage}`); + return { + content: [ + { type: 'text' as const, text: `AreaTool: ${errorMessage}` } + ], + isError: true + }; + } + } + ); + } +} diff --git a/src/tools/bearing-tool/BearingTool.input.schema.ts b/src/tools/bearing-tool/BearingTool.input.schema.ts new file mode 100644 index 0000000..dbd9bed --- /dev/null +++ b/src/tools/bearing-tool/BearingTool.input.schema.ts @@ -0,0 +1,27 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; + +/** + * Input schema for BearingTool + */ +export const BearingInputSchema = z.object({ + from: z + .object({ + longitude: z.number().min(-180).max(180), + latitude: z.number().min(-90).max(90) + }) + .describe('Starting coordinate'), + to: z + .object({ + longitude: z.number().min(-180).max(180), + latitude: z.number().min(-90).max(90) + }) + .describe('Ending coordinate') +}); + +/** + * Type inference for BearingInput + */ +export type BearingInput = z.infer; diff --git a/src/tools/bearing-tool/BearingTool.output.schema.ts b/src/tools/bearing-tool/BearingTool.output.schema.ts new file mode 100644 index 0000000..48051ff --- /dev/null +++ b/src/tools/bearing-tool/BearingTool.output.schema.ts @@ -0,0 +1,24 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Output schema for BearingTool + */ +export const BearingOutputSchema = z.object({ + bearing: z.number().describe('Bearing in degrees (0-360, where 0 is North)'), + from: z.object({ + longitude: z.number(), + latitude: z.number() + }), + to: z.object({ + longitude: z.number(), + latitude: z.number() + }) +}); + +/** + * Type inference for BearingOutput + */ +export type BearingOutput = z.infer; diff --git a/src/tools/bearing-tool/BearingTool.ts b/src/tools/bearing-tool/BearingTool.ts new file mode 100644 index 0000000..10269b5 --- /dev/null +++ b/src/tools/bearing-tool/BearingTool.ts @@ -0,0 +1,107 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { bearing as turfBearing } from '@turf/turf'; +import { context, SpanStatusCode, trace } from '@opentelemetry/api'; +import { createLocalToolExecutionContext } from '../../utils/tracing.js'; +import { BaseTool } from '../BaseTool.js'; +import { BearingInputSchema } from './BearingTool.input.schema.js'; +import { + BearingOutputSchema, + type BearingOutput +} from './BearingTool.output.schema.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; + +/** + * BearingTool - Calculate the bearing between two geographic coordinates + */ +export class BearingTool extends BaseTool< + typeof BearingInputSchema, + typeof BearingOutputSchema +> { + readonly name = 'bearing_tool'; + readonly description = + 'Calculate the bearing (compass direction) from one point to another. ' + + 'Returns bearing in degrees where 0° is North, 90° is East, 180° is South, and 270° is West. ' + + 'Works offline without API calls.'; + + readonly annotations = { + title: 'Calculate Bearing', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: false + }; + + constructor() { + super({ + inputSchema: BearingInputSchema, + outputSchema: BearingOutputSchema + }); + } + + async run(rawInput: unknown): Promise { + const toolContext = createLocalToolExecutionContext(this.name, 0); + return await context.with( + trace.setSpan(context.active(), toolContext.span), + async () => { + try { + const input = BearingInputSchema.parse(rawInput); + const { from, to } = input; + + const bearing = turfBearing( + [from.longitude, from.latitude], + [to.longitude, to.latitude] + ); + + // Convert from -180 to 180 range to 0-360 range + const normalizedBearing = bearing < 0 ? bearing + 360 : bearing; + + const result: BearingOutput = { + bearing: Math.round(normalizedBearing * 100) / 100, + from, + to + }; + + const validatedResult = this.validateOutput(result) as BearingOutput; + + const text = + `Bearing: ${validatedResult.bearing}° ` + + `(${this.bearingToCardinal(validatedResult.bearing)})\n` + + `From: [${validatedResult.from.longitude}, ${validatedResult.from.latitude}]\n` + + `To: [${validatedResult.to.longitude}, ${validatedResult.to.latitude}]`; + + toolContext.span.setStatus({ code: SpanStatusCode.OK }); + toolContext.span.end(); + + return { + content: [{ type: 'text' as const, text }], + structuredContent: validatedResult, + isError: false + }; + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : String(error); + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); + toolContext.span.end(); + this.log('error', `${this.name}: ${errorMessage}`); + return { + content: [ + { type: 'text' as const, text: `BearingTool: ${errorMessage}` } + ], + isError: true + }; + } + } + ); + } + + private bearingToCardinal(bearing: number): string { + const directions = ['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW']; + const index = Math.round(bearing / 45) % 8; + return directions[index]; + } +} diff --git a/src/tools/bounding-box-tool/BoundingBoxTool.input.schema.ts b/src/tools/bounding-box-tool/BoundingBoxTool.input.schema.ts new file mode 100644 index 0000000..634db76 --- /dev/null +++ b/src/tools/bounding-box-tool/BoundingBoxTool.input.schema.ts @@ -0,0 +1,34 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; + +const CoordinateSchema = z + .array(z.number()) + .length(2) + .describe('Coordinate as [longitude, latitude]'); + +/** + * Input schema for BoundingBoxTool + */ +export const BoundingBoxInputSchema = z.object({ + geometry: z + .union([ + // Point + z.array(z.number()).length(2), + // LineString or array of points + z.array(CoordinateSchema).min(1), + // Polygon + z.array(z.array(CoordinateSchema)).min(1), + // MultiPolygon + z.array(z.array(z.array(CoordinateSchema))).min(1) + ]) + .describe( + 'Geometry coordinates (Point, LineString, Polygon, or MultiPolygon)' + ) +}); + +/** + * Type inference for BoundingBoxInput + */ +export type BoundingBoxInput = z.infer; diff --git a/src/tools/bounding-box-tool/BoundingBoxTool.output.schema.ts b/src/tools/bounding-box-tool/BoundingBoxTool.output.schema.ts new file mode 100644 index 0000000..f039015 --- /dev/null +++ b/src/tools/bounding-box-tool/BoundingBoxTool.output.schema.ts @@ -0,0 +1,18 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Output schema for BoundingBoxTool + */ +export const BoundingBoxOutputSchema = z.object({ + bbox: z + .tuple([z.number(), z.number(), z.number(), z.number()]) + .describe('Bounding box as [minLon, minLat, maxLon, maxLat]') +}); + +/** + * Type inference for BoundingBoxOutput + */ +export type BoundingBoxOutput = z.infer; diff --git a/src/tools/bounding-box-tool/BoundingBoxTool.ts b/src/tools/bounding-box-tool/BoundingBoxTool.ts new file mode 100644 index 0000000..601c445 --- /dev/null +++ b/src/tools/bounding-box-tool/BoundingBoxTool.ts @@ -0,0 +1,131 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { + bbox as turfBbox, + point, + lineString, + polygon, + multiPolygon +} from '@turf/turf'; +import { context, SpanStatusCode, trace } from '@opentelemetry/api'; +import { createLocalToolExecutionContext } from '../../utils/tracing.js'; +import { BaseTool } from '../BaseTool.js'; +import { BoundingBoxInputSchema } from './BoundingBoxTool.input.schema.js'; +import { + BoundingBoxOutputSchema, + type BoundingBoxOutput +} from './BoundingBoxTool.output.schema.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; + +/** + * BoundingBoxTool - Calculate the bounding box of a geometry + */ +export class BoundingBoxTool extends BaseTool< + typeof BoundingBoxInputSchema, + typeof BoundingBoxOutputSchema +> { + readonly name = 'bbox_tool'; + readonly description = + 'Calculate the bounding box (extent) of any geometry. ' + + 'Returns the minimum and maximum longitude and latitude that encompass the geometry. ' + + 'Works offline without API calls.'; + + readonly annotations = { + title: 'Calculate Bounding Box', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: false + }; + + constructor() { + super({ + inputSchema: BoundingBoxInputSchema, + outputSchema: BoundingBoxOutputSchema + }); + } + + async run(rawInput: unknown): Promise { + const toolContext = createLocalToolExecutionContext(this.name, 0); + return await context.with( + trace.setSpan(context.active(), toolContext.span), + async () => { + try { + const input = BoundingBoxInputSchema.parse(rawInput); + + // Determine geometry type based on structure depth + let geom; + const depth = this.getArrayDepth(input.geometry); + + if (depth === 1) { + // Point [lon, lat] + geom = point(input.geometry as number[]); + } else if (depth === 2) { + // LineString [[lon, lat], [lon, lat], ...] + geom = lineString(input.geometry as number[][]); + } else if (depth === 3) { + // Polygon [[[lon, lat], ...]] + geom = polygon(input.geometry as number[][][]); + } else { + // MultiPolygon [[[[lon, lat], ...]]] + geom = multiPolygon(input.geometry as number[][][][]); + } + + const bboxArray = turfBbox(geom); + + const result: BoundingBoxOutput = { + bbox: [ + Math.round(bboxArray[0] * 1000000) / 1000000, + Math.round(bboxArray[1] * 1000000) / 1000000, + Math.round(bboxArray[2] * 1000000) / 1000000, + Math.round(bboxArray[3] * 1000000) / 1000000 + ] + }; + + const validatedResult = this.validateOutput( + result + ) as BoundingBoxOutput; + + const text = + `Bounding Box: [${validatedResult.bbox[0]}, ${validatedResult.bbox[1]}, ${validatedResult.bbox[2]}, ${validatedResult.bbox[3]}]\n` + + `Southwest: [${validatedResult.bbox[0]}, ${validatedResult.bbox[1]}]\n` + + `Northeast: [${validatedResult.bbox[2]}, ${validatedResult.bbox[3]}]`; + + toolContext.span.setStatus({ code: SpanStatusCode.OK }); + toolContext.span.end(); + + return { + content: [{ type: 'text' as const, text }], + structuredContent: validatedResult, + isError: false + }; + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : String(error); + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); + toolContext.span.end(); + this.log('error', `${this.name}: ${errorMessage}`); + return { + content: [ + { + type: 'text' as const, + text: `BoundingBoxTool: ${errorMessage}` + } + ], + isError: true + }; + } + } + ); + } + + private getArrayDepth(arr: unknown): number { + if (!Array.isArray(arr)) return 0; + if (!Array.isArray(arr[0])) return 1; + return 1 + this.getArrayDepth(arr[0]); + } +} diff --git a/src/tools/buffer-tool/BufferTool.input.schema.ts b/src/tools/buffer-tool/BufferTool.input.schema.ts new file mode 100644 index 0000000..7f1d7c0 --- /dev/null +++ b/src/tools/buffer-tool/BufferTool.input.schema.ts @@ -0,0 +1,36 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; + +const CoordinateSchema = z + .array(z.number()) + .length(2) + .describe('Coordinate as [longitude, latitude]'); + +/** + * Input schema for BufferTool + */ +export const BufferInputSchema = z.object({ + geometry: z + .union([ + // Point + z.array(z.number()).length(2), + // LineString + z.array(CoordinateSchema).min(2), + // Polygon + z.array(z.array(CoordinateSchema)).min(1) + ]) + .describe('Geometry coordinates (Point, LineString, or Polygon)'), + distance: z.number().positive().describe('Buffer distance'), + units: z + .enum(['kilometers', 'miles', 'meters', 'feet']) + .optional() + .default('kilometers') + .describe('Unit of measurement for distance') +}); + +/** + * Type inference for BufferInput + */ +export type BufferInput = z.infer; diff --git a/src/tools/buffer-tool/BufferTool.output.schema.ts b/src/tools/buffer-tool/BufferTool.output.schema.ts new file mode 100644 index 0000000..19cb039 --- /dev/null +++ b/src/tools/buffer-tool/BufferTool.output.schema.ts @@ -0,0 +1,20 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Output schema for BufferTool + */ +export const BufferOutputSchema = z.object({ + bufferedPolygon: z + .array(z.array(z.tuple([z.number(), z.number()]))) + .describe('Buffer polygon as array of rings'), + distance: z.number(), + units: z.string() +}); + +/** + * Type inference for BufferOutput + */ +export type BufferOutput = z.infer; diff --git a/src/tools/buffer-tool/BufferTool.ts b/src/tools/buffer-tool/BufferTool.ts new file mode 100644 index 0000000..a566c78 --- /dev/null +++ b/src/tools/buffer-tool/BufferTool.ts @@ -0,0 +1,124 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { buffer as turfBuffer, point, lineString, polygon } from '@turf/turf'; +import { context, SpanStatusCode, trace } from '@opentelemetry/api'; +import { createLocalToolExecutionContext } from '../../utils/tracing.js'; +import { BaseTool } from '../BaseTool.js'; +import { BufferInputSchema } from './BufferTool.input.schema.js'; +import { + BufferOutputSchema, + type BufferOutput +} from './BufferTool.output.schema.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; + +/** + * BufferTool - Create a buffer zone around a geometry + */ +export class BufferTool extends BaseTool< + typeof BufferInputSchema, + typeof BufferOutputSchema +> { + readonly name = 'buffer_tool'; + readonly description = + 'Create a buffer zone (polygon) around a point, line, or polygon at a specified distance. ' + + 'Useful for proximity analysis, service areas, or creating zones of influence. ' + + 'Works offline without API calls.'; + + readonly annotations = { + title: 'Create Buffer Zone', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: false + }; + + constructor() { + super({ + inputSchema: BufferInputSchema, + outputSchema: BufferOutputSchema + }); + } + + async run(rawInput: unknown): Promise { + const toolContext = createLocalToolExecutionContext(this.name, 0); + return await context.with( + trace.setSpan(context.active(), toolContext.span), + async () => { + try { + const input = BufferInputSchema.parse(rawInput); + + // Determine geometry type based on structure + let geom; + const depth = this.getArrayDepth(input.geometry); + + if (depth === 1) { + // Point [lon, lat] + geom = point(input.geometry as number[]); + } else if (depth === 2) { + // LineString [[lon, lat], [lon, lat], ...] + geom = lineString(input.geometry as number[][]); + } else { + // Polygon [[[lon, lat], ...]] + geom = polygon(input.geometry as number[][][]); + } + + const buffered = turfBuffer(geom, input.distance, { + units: input.units + }); + + if (!buffered || buffered.geometry.type !== 'Polygon') { + throw new Error('Buffer operation did not produce a valid polygon'); + } + + const result: BufferOutput = { + bufferedPolygon: buffered.geometry.coordinates as [ + number, + number + ][][], + distance: input.distance, + units: input.units + }; + + const validatedResult = this.validateOutput(result) as BufferOutput; + + const ringCount = validatedResult.bufferedPolygon.length; + const text = + `Buffer zone created: ${validatedResult.distance} ${validatedResult.units}\n` + + `Result: Polygon with ${ringCount} ring${ringCount !== 1 ? 's' : ''} ` + + `(${validatedResult.bufferedPolygon[0].length} vertices in outer ring)`; + + toolContext.span.setStatus({ code: SpanStatusCode.OK }); + toolContext.span.end(); + + return { + content: [{ type: 'text' as const, text }], + structuredContent: validatedResult, + isError: false + }; + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : String(error); + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); + toolContext.span.end(); + this.log('error', `${this.name}: ${errorMessage}`); + return { + content: [ + { type: 'text' as const, text: `BufferTool: ${errorMessage}` } + ], + isError: true + }; + } + } + ); + } + + private getArrayDepth(arr: unknown): number { + if (!Array.isArray(arr)) return 0; + if (!Array.isArray(arr[0])) return 1; + return 1 + this.getArrayDepth(arr[0]); + } +} diff --git a/src/tools/centroid-tool/CentroidTool.input.schema.ts b/src/tools/centroid-tool/CentroidTool.input.schema.ts new file mode 100644 index 0000000..cb7a614 --- /dev/null +++ b/src/tools/centroid-tool/CentroidTool.input.schema.ts @@ -0,0 +1,32 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; + +const CoordinateSchema = z + .array(z.number()) + .length(2) + .describe('Coordinate as [longitude, latitude]'); + +/** + * Input schema for CentroidTool + */ +export const CentroidInputSchema = z.object({ + geometry: z + .union([ + // Polygon + z.array(z.array(CoordinateSchema)).min(1), + // MultiPolygon + z.array(z.array(z.array(CoordinateSchema))).min(1) + ]) + .describe( + 'Polygon or MultiPolygon coordinates. ' + + 'Polygon: array of rings (first is outer, rest are holes). ' + + 'MultiPolygon: array of polygons.' + ) +}); + +/** + * Type inference for CentroidInput + */ +export type CentroidInput = z.infer; diff --git a/src/tools/centroid-tool/CentroidTool.output.schema.ts b/src/tools/centroid-tool/CentroidTool.output.schema.ts new file mode 100644 index 0000000..74d92b7 --- /dev/null +++ b/src/tools/centroid-tool/CentroidTool.output.schema.ts @@ -0,0 +1,19 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Output schema for CentroidTool + */ +export const CentroidOutputSchema = z.object({ + centroid: z.object({ + longitude: z.number(), + latitude: z.number() + }) +}); + +/** + * Type inference for CentroidOutput + */ +export type CentroidOutput = z.infer; diff --git a/src/tools/centroid-tool/CentroidTool.ts b/src/tools/centroid-tool/CentroidTool.ts new file mode 100644 index 0000000..72b9cdb --- /dev/null +++ b/src/tools/centroid-tool/CentroidTool.ts @@ -0,0 +1,103 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { centroid as turfCentroid, polygon, multiPolygon } from '@turf/turf'; +import { context, SpanStatusCode, trace } from '@opentelemetry/api'; +import { createLocalToolExecutionContext } from '../../utils/tracing.js'; +import { BaseTool } from '../BaseTool.js'; +import { CentroidInputSchema } from './CentroidTool.input.schema.js'; +import { + CentroidOutputSchema, + type CentroidOutput +} from './CentroidTool.output.schema.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; + +/** + * CentroidTool - Calculate the center point (centroid) of a polygon or multipolygon + */ +export class CentroidTool extends BaseTool< + typeof CentroidInputSchema, + typeof CentroidOutputSchema +> { + readonly name = 'centroid_tool'; + readonly description = + 'Calculate the geometric center (centroid) of a polygon or multipolygon. ' + + 'The centroid is the arithmetic mean position of all points in the shape. ' + + 'Works offline without API calls.'; + + readonly annotations = { + title: 'Calculate Centroid', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: false + }; + + constructor() { + super({ + inputSchema: CentroidInputSchema, + outputSchema: CentroidOutputSchema + }); + } + + async run(rawInput: unknown): Promise { + const toolContext = createLocalToolExecutionContext(this.name, 0); + return await context.with( + trace.setSpan(context.active(), toolContext.span), + async () => { + try { + const input = CentroidInputSchema.parse(rawInput); + + // Determine if it's a polygon or multipolygon based on depth + const isMultiPolygon = + Array.isArray(input.geometry[0]) && + Array.isArray(input.geometry[0][0]) && + Array.isArray(input.geometry[0][0][0]); + + const geom = isMultiPolygon + ? multiPolygon(input.geometry as number[][][][]) + : polygon(input.geometry as number[][][]); + + const center = turfCentroid(geom); + + const result: CentroidOutput = { + centroid: { + longitude: + Math.round(center.geometry.coordinates[0] * 1000000) / 1000000, + latitude: + Math.round(center.geometry.coordinates[1] * 1000000) / 1000000 + } + }; + + const validatedResult = this.validateOutput(result) as CentroidOutput; + + const text = `Centroid: [${validatedResult.centroid.longitude}, ${validatedResult.centroid.latitude}]`; + + toolContext.span.setStatus({ code: SpanStatusCode.OK }); + toolContext.span.end(); + + return { + content: [{ type: 'text' as const, text }], + structuredContent: validatedResult, + isError: false + }; + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : String(error); + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); + toolContext.span.end(); + this.log('error', `${this.name}: ${errorMessage}`); + return { + content: [ + { type: 'text' as const, text: `CentroidTool: ${errorMessage}` } + ], + isError: true + }; + } + } + ); + } +} diff --git a/src/tools/midpoint-tool/MidpointTool.input.schema.ts b/src/tools/midpoint-tool/MidpointTool.input.schema.ts new file mode 100644 index 0000000..5193f00 --- /dev/null +++ b/src/tools/midpoint-tool/MidpointTool.input.schema.ts @@ -0,0 +1,27 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; + +/** + * Input schema for MidpointTool + */ +export const MidpointInputSchema = z.object({ + from: z + .object({ + longitude: z.number().min(-180).max(180), + latitude: z.number().min(-90).max(90) + }) + .describe('Starting coordinate'), + to: z + .object({ + longitude: z.number().min(-180).max(180), + latitude: z.number().min(-90).max(90) + }) + .describe('Ending coordinate') +}); + +/** + * Type inference for MidpointInput + */ +export type MidpointInput = z.infer; diff --git a/src/tools/midpoint-tool/MidpointTool.output.schema.ts b/src/tools/midpoint-tool/MidpointTool.output.schema.ts new file mode 100644 index 0000000..5121546 --- /dev/null +++ b/src/tools/midpoint-tool/MidpointTool.output.schema.ts @@ -0,0 +1,27 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Output schema for MidpointTool + */ +export const MidpointOutputSchema = z.object({ + midpoint: z.object({ + longitude: z.number(), + latitude: z.number() + }), + from: z.object({ + longitude: z.number(), + latitude: z.number() + }), + to: z.object({ + longitude: z.number(), + latitude: z.number() + }) +}); + +/** + * Type inference for MidpointOutput + */ +export type MidpointOutput = z.infer; diff --git a/src/tools/midpoint-tool/MidpointTool.ts b/src/tools/midpoint-tool/MidpointTool.ts new file mode 100644 index 0000000..d29f580 --- /dev/null +++ b/src/tools/midpoint-tool/MidpointTool.ts @@ -0,0 +1,101 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { midpoint as turfMidpoint, point } from '@turf/turf'; +import { context, SpanStatusCode, trace } from '@opentelemetry/api'; +import { createLocalToolExecutionContext } from '../../utils/tracing.js'; +import { BaseTool } from '../BaseTool.js'; +import { MidpointInputSchema } from './MidpointTool.input.schema.js'; +import { + MidpointOutputSchema, + type MidpointOutput +} from './MidpointTool.output.schema.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; + +/** + * MidpointTool - Calculate the geographic midpoint between two coordinates + */ +export class MidpointTool extends BaseTool< + typeof MidpointInputSchema, + typeof MidpointOutputSchema +> { + readonly name = 'midpoint_tool'; + readonly description = + 'Calculate the geographic midpoint between two coordinates. ' + + 'Returns the point that is halfway between the two input points along the great circle path. ' + + 'Works offline without API calls.'; + + readonly annotations = { + title: 'Calculate Midpoint', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: false + }; + + constructor() { + super({ + inputSchema: MidpointInputSchema, + outputSchema: MidpointOutputSchema + }); + } + + async run(rawInput: unknown): Promise { + const toolContext = createLocalToolExecutionContext(this.name, 0); + return await context.with( + trace.setSpan(context.active(), toolContext.span), + async () => { + try { + const input = MidpointInputSchema.parse(rawInput); + const { from, to } = input; + + const pt1 = point([from.longitude, from.latitude]); + const pt2 = point([to.longitude, to.latitude]); + const mid = turfMidpoint(pt1, pt2); + + const result: MidpointOutput = { + midpoint: { + longitude: + Math.round(mid.geometry.coordinates[0] * 1000000) / 1000000, + latitude: + Math.round(mid.geometry.coordinates[1] * 1000000) / 1000000 + }, + from, + to + }; + + const validatedResult = this.validateOutput(result) as MidpointOutput; + + const text = + `Midpoint: [${validatedResult.midpoint.longitude}, ${validatedResult.midpoint.latitude}]\n` + + `From: [${validatedResult.from.longitude}, ${validatedResult.from.latitude}]\n` + + `To: [${validatedResult.to.longitude}, ${validatedResult.to.latitude}]`; + + toolContext.span.setStatus({ code: SpanStatusCode.OK }); + toolContext.span.end(); + + return { + content: [{ type: 'text' as const, text }], + structuredContent: validatedResult, + isError: false + }; + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : String(error); + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); + toolContext.span.end(); + this.log('error', `${this.name}: ${errorMessage}`); + return { + content: [ + { type: 'text' as const, text: `MidpointTool: ${errorMessage}` } + ], + isError: true + }; + } + } + ); + } +} diff --git a/src/tools/point-in-polygon-tool/PointInPolygonTool.input.schema.ts b/src/tools/point-in-polygon-tool/PointInPolygonTool.input.schema.ts new file mode 100644 index 0000000..104a2ab --- /dev/null +++ b/src/tools/point-in-polygon-tool/PointInPolygonTool.input.schema.ts @@ -0,0 +1,36 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; + +/** + * GeoJSON coordinate schema [longitude, latitude] + */ +const CoordinateSchema = z + .array(z.number()) + .length(2) + .describe('Coordinate as [longitude, latitude]'); + +/** + * Input schema for PointInPolygonTool + */ +export const PointInPolygonInputSchema = z.object({ + point: z + .object({ + longitude: z.number().min(-180).max(180), + latitude: z.number().min(-90).max(90) + }) + .describe('Point coordinate to test'), + + polygon: z + .array(z.array(CoordinateSchema)) + .min(1) + .describe( + 'Polygon coordinates as array of rings (first is outer, rest are holes). Each ring is [longitude, latitude] pairs.' + ) +}); + +/** + * Type inference for PointInPolygonInput + */ +export type PointInPolygonInput = z.infer; diff --git a/src/tools/point-in-polygon-tool/PointInPolygonTool.output.schema.ts b/src/tools/point-in-polygon-tool/PointInPolygonTool.output.schema.ts new file mode 100644 index 0000000..f140463 --- /dev/null +++ b/src/tools/point-in-polygon-tool/PointInPolygonTool.output.schema.ts @@ -0,0 +1,22 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Output schema for PointInPolygonTool + */ +export const PointInPolygonOutputSchema = z.object({ + inside: z.boolean().describe('Whether the point is inside the polygon'), + point: z + .object({ + longitude: z.number(), + latitude: z.number() + }) + .describe('The tested point') +}); + +/** + * Type inference for PointInPolygonOutput + */ +export type PointInPolygonOutput = z.infer; diff --git a/src/tools/point-in-polygon-tool/PointInPolygonTool.ts b/src/tools/point-in-polygon-tool/PointInPolygonTool.ts new file mode 100644 index 0000000..7b916f5 --- /dev/null +++ b/src/tools/point-in-polygon-tool/PointInPolygonTool.ts @@ -0,0 +1,104 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { booleanPointInPolygon, polygon, point } from '@turf/turf'; +import { context, SpanStatusCode, trace } from '@opentelemetry/api'; +import { createLocalToolExecutionContext } from '../../utils/tracing.js'; +import { BaseTool } from '../BaseTool.js'; +import { PointInPolygonInputSchema } from './PointInPolygonTool.input.schema.js'; +import { + PointInPolygonOutputSchema, + type PointInPolygonOutput +} from './PointInPolygonTool.output.schema.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; + +/** + * PointInPolygonTool - Test if a point is inside a polygon + * + * This is an offline tool that performs local geometric calculations without API calls. + * Useful for spatial queries like "is this delivery point within this service area?" + */ +export class PointInPolygonTool extends BaseTool< + typeof PointInPolygonInputSchema, + typeof PointInPolygonOutputSchema +> { + readonly name = 'point_in_polygon_tool'; + readonly description = + 'Test if a geographic point is inside a polygon. ' + + 'Useful for determining if a location is within a boundary, service area, or region. ' + + 'Handles polygons with holes. Works offline without API calls.'; + + readonly annotations = { + title: 'Point in Polygon Test', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: false + }; + + constructor() { + super({ + inputSchema: PointInPolygonInputSchema, + outputSchema: PointInPolygonOutputSchema + }); + } + + async run(rawInput: unknown): Promise { + const toolContext = createLocalToolExecutionContext(this.name, 0); + return await context.with( + trace.setSpan(context.active(), toolContext.span), + async () => { + try { + const input = PointInPolygonInputSchema.parse(rawInput); + + // Create Turf geometries + const pt = point([input.point.longitude, input.point.latitude]); + const poly = polygon(input.polygon); + + // Test if point is inside polygon + const inside = booleanPointInPolygon(pt, poly); + + const result: PointInPolygonOutput = { + inside, + point: input.point + }; + + const validatedResult = this.validateOutput( + result + ) as PointInPolygonOutput; + + const text = validatedResult.inside + ? `✓ Point [${validatedResult.point.longitude}, ${validatedResult.point.latitude}] is INSIDE the polygon` + : `✗ Point [${validatedResult.point.longitude}, ${validatedResult.point.latitude}] is OUTSIDE the polygon`; + + toolContext.span.setStatus({ code: SpanStatusCode.OK }); + toolContext.span.end(); + + return { + content: [{ type: 'text' as const, text }], + structuredContent: validatedResult, + isError: false + }; + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : String(error); + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); + toolContext.span.end(); + this.log('error', `${this.name}: ${errorMessage}`); + return { + content: [ + { + type: 'text' as const, + text: `PointInPolygonTool: ${errorMessage}` + } + ], + isError: true + }; + } + } + ); + } +} diff --git a/src/tools/simplify-tool/SimplifyTool.input.schema.ts b/src/tools/simplify-tool/SimplifyTool.input.schema.ts new file mode 100644 index 0000000..8e7efe8 --- /dev/null +++ b/src/tools/simplify-tool/SimplifyTool.input.schema.ts @@ -0,0 +1,43 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; + +const CoordinateSchema = z + .array(z.number()) + .length(2) + .describe('Coordinate as [longitude, latitude]'); + +/** + * Input schema for SimplifyTool + */ +export const SimplifyInputSchema = z.object({ + geometry: z + .union([ + // LineString + z.array(CoordinateSchema).min(2), + // Polygon + z.array(z.array(CoordinateSchema)).min(1) + ]) + .describe('LineString or Polygon coordinates'), + tolerance: z + .number() + .positive() + .optional() + .default(0.01) + .describe( + 'Simplification tolerance (higher values = more simplification). Default: 0.01' + ), + highQuality: z + .boolean() + .optional() + .default(false) + .describe( + 'Use high quality simplification (slower but more accurate). Default: false' + ) +}); + +/** + * Type inference for SimplifyInput + */ +export type SimplifyInput = z.infer; diff --git a/src/tools/simplify-tool/SimplifyTool.output.schema.ts b/src/tools/simplify-tool/SimplifyTool.output.schema.ts new file mode 100644 index 0000000..79f8d21 --- /dev/null +++ b/src/tools/simplify-tool/SimplifyTool.output.schema.ts @@ -0,0 +1,26 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Output schema for SimplifyTool + */ +export const SimplifyOutputSchema = z.object({ + simplified: z + .union([ + // LineString + z.array(z.tuple([z.number(), z.number()])), + // Polygon + z.array(z.array(z.tuple([z.number(), z.number()]))) + ]) + .describe('Simplified geometry coordinates'), + originalVertexCount: z.number(), + simplifiedVertexCount: z.number(), + reductionPercentage: z.number() +}); + +/** + * Type inference for SimplifyOutput + */ +export type SimplifyOutput = z.infer; diff --git a/src/tools/simplify-tool/SimplifyTool.ts b/src/tools/simplify-tool/SimplifyTool.ts new file mode 100644 index 0000000..24a4a49 --- /dev/null +++ b/src/tools/simplify-tool/SimplifyTool.ts @@ -0,0 +1,137 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { simplify as turfSimplify, lineString, polygon } from '@turf/turf'; +import { context, SpanStatusCode, trace } from '@opentelemetry/api'; +import { createLocalToolExecutionContext } from '../../utils/tracing.js'; +import { BaseTool } from '../BaseTool.js'; +import { SimplifyInputSchema } from './SimplifyTool.input.schema.js'; +import { + SimplifyOutputSchema, + type SimplifyOutput +} from './SimplifyTool.output.schema.js'; +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; + +/** + * SimplifyTool - Simplify geometries by reducing vertex count + */ +export class SimplifyTool extends BaseTool< + typeof SimplifyInputSchema, + typeof SimplifyOutputSchema +> { + readonly name = 'simplify_tool'; + readonly description = + 'Simplify a LineString or Polygon by reducing the number of vertices while preserving the general shape. ' + + 'Uses the Douglas-Peucker algorithm. Useful for reducing file sizes and improving rendering performance. ' + + 'Works offline without API calls.'; + + readonly annotations = { + title: 'Simplify Geometry', + readOnlyHint: true, + destructiveHint: false, + idempotentHint: true, + openWorldHint: false + }; + + constructor() { + super({ + inputSchema: SimplifyInputSchema, + outputSchema: SimplifyOutputSchema + }); + } + + async run(rawInput: unknown): Promise { + const toolContext = createLocalToolExecutionContext(this.name, 0); + return await context.with( + trace.setSpan(context.active(), toolContext.span), + async () => { + try { + const input = SimplifyInputSchema.parse(rawInput); + + // Determine if it's a LineString or Polygon + const isPolygon = + Array.isArray(input.geometry[0]) && + Array.isArray(input.geometry[0][0]); + + const geom = isPolygon + ? polygon(input.geometry as number[][][]) + : lineString(input.geometry as number[][]); + + // Count original vertices + const originalVertexCount = this.countVertices(input.geometry); + + // Simplify the geometry + const simplified = turfSimplify(geom, { + tolerance: input.tolerance, + highQuality: input.highQuality + }); + + // Extract simplified coordinates + const simplifiedCoords = simplified.geometry.coordinates; + + // Count simplified vertices + const simplifiedVertexCount = this.countVertices(simplifiedCoords); + + // Calculate reduction percentage + const reductionPercentage = Math.round( + ((originalVertexCount - simplifiedVertexCount) / + originalVertexCount) * + 100 + ); + + const result: SimplifyOutput = { + simplified: simplifiedCoords as any, + originalVertexCount, + simplifiedVertexCount, + reductionPercentage + }; + + const validatedResult = this.validateOutput(result) as SimplifyOutput; + + const text = + `Geometry simplified:\n` + + `Original vertices: ${validatedResult.originalVertexCount}\n` + + `Simplified vertices: ${validatedResult.simplifiedVertexCount}\n` + + `Reduction: ${validatedResult.reductionPercentage}%`; + + toolContext.span.setStatus({ code: SpanStatusCode.OK }); + toolContext.span.end(); + + return { + content: [{ type: 'text' as const, text }], + structuredContent: validatedResult, + isError: false + }; + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : String(error); + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); + toolContext.span.end(); + this.log('error', `${this.name}: ${errorMessage}`); + return { + content: [ + { type: 'text' as const, text: `SimplifyTool: ${errorMessage}` } + ], + isError: true + }; + } + } + ); + } + + private countVertices(coords: unknown): number { + if (!Array.isArray(coords)) return 0; + if (typeof coords[0] === 'number') return 1; + if (Array.isArray(coords[0]) && typeof coords[0][0] === 'number') { + return coords.length; + } + // Polygon - count all vertices in all rings + return coords.reduce( + (sum, ring) => sum + (Array.isArray(ring) ? ring.length : 0), + 0 + ); + } +} diff --git a/src/tools/toolRegistry.ts b/src/tools/toolRegistry.ts index ece161e..2bc7579 100644 --- a/src/tools/toolRegistry.ts +++ b/src/tools/toolRegistry.ts @@ -2,6 +2,14 @@ // Licensed under the MIT License. // INSERT NEW TOOL IMPORT HERE +import { SimplifyTool } from './simplify-tool/SimplifyTool.js'; +import { BoundingBoxTool } from './bounding-box-tool/BoundingBoxTool.js'; +import { CentroidTool } from './centroid-tool/CentroidTool.js'; +import { MidpointTool } from './midpoint-tool/MidpointTool.js'; +import { BearingTool } from './bearing-tool/BearingTool.js'; +import { AreaTool } from './area-tool/AreaTool.js'; +import { BufferTool } from './buffer-tool/BufferTool.js'; +import { PointInPolygonTool } from './point-in-polygon-tool/PointInPolygonTool.js'; import { DistanceTool } from './distance-tool/DistanceTool.js'; import { CategoryListTool } from './category-list-tool/CategoryListTool.js'; import { CategorySearchTool } from './category-search-tool/CategorySearchTool.js'; @@ -20,6 +28,14 @@ import { httpRequest } from '../utils/httpPipeline.js'; // Central registry of all tools export const ALL_TOOLS = [ // INSERT NEW TOOL INSTANCE HERE + new SimplifyTool(), + new BoundingBoxTool(), + new CentroidTool(), + new MidpointTool(), + new BearingTool(), + new AreaTool(), + new BufferTool(), + new PointInPolygonTool(), new DistanceTool(), new VersionTool(), new ResourceReaderTool(), diff --git a/test/tools/annotations.test.ts b/test/tools/annotations.test.ts index e7a9e41..76f6a10 100644 --- a/test/tools/annotations.test.ts +++ b/test/tools/annotations.test.ts @@ -63,7 +63,18 @@ describe('Tool Annotations', () => { // Most Mapbox API tools interact with external services (open world) // Exclude offline/local tools that don't make external API calls - const offlineTools = ['version_tool', 'distance_tool']; + const offlineTools = [ + 'version_tool', + 'distance_tool', + 'point_in_polygon_tool', + 'bearing_tool', + 'midpoint_tool', + 'centroid_tool', + 'area_tool', + 'bbox_tool', + 'buffer_tool', + 'simplify_tool' + ]; const apiTools = tools.filter((tool) => !offlineTools.includes(tool.name)); apiTools.forEach((tool) => { @@ -74,7 +85,18 @@ describe('Tool Annotations', () => { it('should have closed world hint for offline tools', () => { const tools = getAllTools(); const offlineTools = tools.filter((tool) => - ['version_tool', 'distance_tool'].includes(tool.name) + [ + 'version_tool', + 'distance_tool', + 'point_in_polygon_tool', + 'bearing_tool', + 'midpoint_tool', + 'centroid_tool', + 'area_tool', + 'bbox_tool', + 'buffer_tool', + 'simplify_tool' + ].includes(tool.name) ); offlineTools.forEach((tool) => { From 88d920a407aeaec61a03193d229c442de223cdc6 Mon Sep 17 00:00:00 2001 From: Matthew Podwysocki Date: Wed, 7 Jan 2026 14:21:57 -0500 Subject: [PATCH 6/8] Update @modelcontextprotocol/sdk to 1.25.2 (CVE fix) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Update SDK from 1.25.1 to 1.25.2 which includes security fixes. Update patch file to match new SDK version. All 457 tests passing with updated SDK. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 --- package-lock.json | 8 +-- package.json | 2 +- ...=> @modelcontextprotocol+sdk+1.25.2.patch} | 60 +------------------ 3 files changed, 7 insertions(+), 63 deletions(-) rename patches/{@modelcontextprotocol+sdk+1.25.1.patch => @modelcontextprotocol+sdk+1.25.2.patch} (59%) diff --git a/package-lock.json b/package-lock.json index b4cb92a..4a2f473 100644 --- a/package-lock.json +++ b/package-lock.json @@ -11,7 +11,7 @@ "license": "MIT", "dependencies": { "@mcp-ui/server": "^5.13.1", - "@modelcontextprotocol/sdk": "^1.25.1", + "@modelcontextprotocol/sdk": "^1.25.2", "@opentelemetry/api": "^1.9.0", "@opentelemetry/auto-instrumentations-node": "^0.56.0", "@opentelemetry/exporter-trace-otlp-http": "^0.56.0", @@ -1914,9 +1914,9 @@ } }, "node_modules/@modelcontextprotocol/sdk": { - "version": "1.25.1", - "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.25.1.tgz", - "integrity": "sha512-yO28oVFFC7EBoiKdAn+VqRm+plcfv4v0xp6osG/VsCB0NlPZWi87ajbCZZ8f/RvOFLEu7//rSRmuZZ7lMoe3gQ==", + "version": "1.25.2", + "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.25.2.tgz", + "integrity": "sha512-LZFeo4F9M5qOhC/Uc1aQSrBHxMrvxett+9KLHt7OhcExtoiRN9DKgbZffMP/nxjutWDQpfMDfP3nkHI4X9ijww==", "license": "MIT", "dependencies": { "@hono/node-server": "^1.19.7", diff --git a/package.json b/package.json index 0f28153..a2f87b7 100644 --- a/package.json +++ b/package.json @@ -76,7 +76,7 @@ ], "dependencies": { "@mcp-ui/server": "^5.13.1", - "@modelcontextprotocol/sdk": "^1.25.1", + "@modelcontextprotocol/sdk": "^1.25.2", "@opentelemetry/api": "^1.9.0", "@opentelemetry/auto-instrumentations-node": "^0.56.0", "@opentelemetry/exporter-trace-otlp-http": "^0.56.0", diff --git a/patches/@modelcontextprotocol+sdk+1.25.1.patch b/patches/@modelcontextprotocol+sdk+1.25.2.patch similarity index 59% rename from patches/@modelcontextprotocol+sdk+1.25.1.patch rename to patches/@modelcontextprotocol+sdk+1.25.2.patch index 7eb8747..b12031b 100644 --- a/patches/@modelcontextprotocol+sdk+1.25.1.patch +++ b/patches/@modelcontextprotocol+sdk+1.25.2.patch @@ -32,20 +32,10 @@ index e10bb3d..2e99bee 100644 } /** diff --git a/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js b/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js -index 23639ce..75f18b5 100644 +index 23639ce..7b8a325 100644 --- a/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js +++ b/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js -@@ -85,6 +85,9 @@ export class McpServer { - execution: tool.execution, - _meta: tool._meta - }; -+ if (tool.icons) { -+ toolDefinition.icons = tool.icons; -+ } - if (tool.outputSchema) { - const obj = normalizeObjectSchema(tool.outputSchema); - if (obj) { -@@ -194,15 +197,20 @@ export class McpServer { +@@ -194,15 +194,20 @@ export class McpServer { return; } if (!result.structuredContent) { @@ -74,49 +64,3 @@ index 23639ce..75f18b5 100644 } } /** -@@ -602,7 +610,7 @@ export class McpServer { - } - return registeredPrompt; - } -- _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) { -+ _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, icons, handler) { - // Validate tool name according to SEP specification - validateAndWarnToolName(name); - const registeredTool = { -@@ -613,6 +621,7 @@ export class McpServer { - annotations, - execution, - _meta, -+ icons, - handler: handler, - enabled: true, - disable: () => registeredTool.update({ enabled: false }), -@@ -641,6 +650,8 @@ export class McpServer { - registeredTool.annotations = updates.annotations; - if (typeof updates._meta !== 'undefined') - registeredTool._meta = updates._meta; -+ if (typeof updates.icons !== 'undefined') -+ registeredTool.icons = updates.icons; - if (typeof updates.enabled !== 'undefined') - registeredTool.enabled = updates.enabled; - this.sendToolListChanged(); -@@ -690,7 +701,7 @@ export class McpServer { - } - } - const callback = rest[0]; -- return this._createRegisteredTool(name, undefined, description, inputSchema, outputSchema, annotations, { taskSupport: 'forbidden' }, undefined, callback); -+ return this._createRegisteredTool(name, undefined, description, inputSchema, outputSchema, annotations, { taskSupport: 'forbidden' }, undefined, undefined, callback); - } - /** - * Registers a tool with a config object and callback. -@@ -699,8 +710,8 @@ export class McpServer { - if (this._registeredTools[name]) { - throw new Error(`Tool ${name} is already registered`); - } -- const { title, description, inputSchema, outputSchema, annotations, _meta } = config; -- return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: 'forbidden' }, _meta, cb); -+ const { title, description, inputSchema, outputSchema, annotations, _meta, icons } = config; -+ return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: 'forbidden' }, _meta, icons, cb); - } - prompt(name, ...rest) { - if (this._registeredPrompts[name]) { From 25d3612dd7e3bff7b2a02aef4a6100cb6960ff46 Mon Sep 17 00:00:00 2001 From: Matthew Podwysocki Date: Wed, 7 Jan 2026 16:16:09 -0500 Subject: [PATCH 7/8] Add test to verify V1 API format in optimization tool MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Explicitly verify that the optimization tool sends version: 1 in the request body to the v2 endpoint, which accepts V1 format for backward compatibility. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 --- test/tools/optimization-tool/OptimizationTool.test.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/tools/optimization-tool/OptimizationTool.test.ts b/test/tools/optimization-tool/OptimizationTool.test.ts index 3aa688b..482e2a6 100644 --- a/test/tools/optimization-tool/OptimizationTool.test.ts +++ b/test/tools/optimization-tool/OptimizationTool.test.ts @@ -157,6 +157,9 @@ describe('OptimizationTool', () => { const firstCall = mockHttpRequest.mock.calls[0]; const postBody = JSON.parse((firstCall[1] as { body: string }).body); + // Verify using V1 API format + expect(postBody.version).toBe(1); + expect(postBody.locations).toHaveLength(3); expect(postBody.locations[0].name).toBe('location-0'); expect(postBody.vehicles).toHaveLength(1); From 0fd375dd7ffd294e599d76b19e98d83005b520a6 Mon Sep 17 00:00:00 2001 From: Matthew Podwysocki Date: Wed, 7 Jan 2026 18:06:44 -0500 Subject: [PATCH 8/8] Refactor optimization tool to use V1 API with V2 ready for future MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Switch optimization_tool to use V1 synchronous GET API (publicly available) - V1 supports 2-12 coordinates, simple TSP, works immediately - Preserve V2 implementation as OptimizationV2Tool (not registered) - V2 code ready to enable when API becomes public - Remove task-based infrastructure from main registration - All 456 tests passing V1 endpoint: GET /optimized-trips/v1/{profile}/{coordinates} V2 endpoint: POST /optimized-trips/v2 (requires beta access) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 --- src/index.ts | 23 +- .../OptimizationTool.input.schema.ts | 216 ++----- .../OptimizationTool.output.schema.ts | 152 ++--- .../optimization-tool/OptimizationTool.ts | 397 +++++-------- .../OptimizationV2Tool.input.schema.ts | 215 +++++++ .../OptimizationV2Tool.output.schema.ts | 139 +++++ ...imizationTask.ts => OptimizationV2Tool.ts} | 55 +- .../OptimizationTool.test.ts | 533 ++++++------------ 8 files changed, 801 insertions(+), 929 deletions(-) create mode 100644 src/tools/optimization-tool/OptimizationV2Tool.input.schema.ts create mode 100644 src/tools/optimization-tool/OptimizationV2Tool.output.schema.ts rename src/tools/optimization-tool/{OptimizationTask.ts => OptimizationV2Tool.ts} (87%) diff --git a/src/index.ts b/src/index.ts index 6e6fbd7..fa85583 100644 --- a/src/index.ts +++ b/src/index.ts @@ -15,17 +15,11 @@ import { ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js'; -import { - InMemoryTaskStore, - InMemoryTaskMessageQueue -} from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js'; import { parseToolConfigFromArgs, filterTools } from './config/toolConfig.js'; import { getAllTools } from './tools/toolRegistry.js'; import { getAllResources } from './resources/resourceRegistry.js'; import { getAllPrompts, getPromptByName } from './prompts/promptRegistry.js'; import { getVersionInfo } from './utils/versionUtils.js'; -import { registerOptimizationTask } from './tools/optimization-tool/OptimizationTask.js'; -import { httpRequest } from './utils/httpPipeline.js'; import { initializeTracing, shutdownTracing, @@ -68,9 +62,6 @@ const enabledTools = filterTools(allTools, config); // Get all resources const allResources = getAllResources(); -// Create task store for async operations -const taskStore = new InMemoryTaskStore(); - // Create an MCP server const server = new McpServer( { @@ -81,26 +72,16 @@ const server = new McpServer( capabilities: { tools: {}, resources: {}, - prompts: {}, - tasks: { requests: { tools: { call: {} } } } - }, - taskStore, - taskMessageQueue: new InMemoryTaskMessageQueue() + prompts: {} + } } ); // Register enabled tools to the server enabledTools.forEach((tool) => { - // Skip OptimizationTool as it's registered as a task instead - if (tool.name === 'optimization_tool') { - return; - } tool.installTo(server); }); -// Register task-based tools -registerOptimizationTask(server, httpRequest); - // Register all resources to the server allResources.forEach((resource) => { resource.installTo(server); diff --git a/src/tools/optimization-tool/OptimizationTool.input.schema.ts b/src/tools/optimization-tool/OptimizationTool.input.schema.ts index ca4b2bb..aad2b5e 100644 --- a/src/tools/optimization-tool/OptimizationTool.input.schema.ts +++ b/src/tools/optimization-tool/OptimizationTool.input.schema.ts @@ -14,199 +14,71 @@ const profileSchema = z ]) .describe('Routing profile'); -// * Input schema for OptimizationTool (Minimal) -// * -// * Accepts an array of coordinates and a routing profile. -// * The tool internally converts this to the full Optimization API v2 request format. - -const optionsSchema = z.object({ - objectives: z - .array( - z.enum(['min-total-travel-duration', 'min-schedule-completion-time']) - ) - .optional() - .describe('Optimization objectives') -}); - -const iso8601Schema = z - .string() - .regex( - /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?([+-]\d{2}:\d{2}|Z)?$/, - 'Must be a valid ISO 8601 datetime string (e.g., 2023-07-22T14:29:23-07:00)' - ); - -const timeWindowSchema = z.object({ - earliest: iso8601Schema.describe('Earliest time for this window'), - latest: iso8601Schema.describe('Latest time for this window'), - type: z - .enum(['strict', 'soft', 'soft_start', 'soft_end']) - .optional() - .describe('Type of time window constraint') -}); - -const vehicleBreakSchema = z.object({ - earliest_start: iso8601Schema.describe('Earliest start time for break'), - latest_end: iso8601Schema.describe('Latest end time for break'), - duration: z.number().int().positive().describe('Break duration in seconds') -}); - -const vehicleSchema = z.object({ - name: z.string().describe('Unique identifier for this vehicle'), - routing_profile: profileSchema - .optional() - .describe('Routing profile for this vehicle'), - start_location: z - .string() - .optional() - .describe( - 'Starting location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' - ), - end_location: z - .string() - .optional() - .describe( - 'Ending location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' - ), - capacities: z - .record(z.number()) - .optional() - .describe('Custom capacity dimensions (e.g., weight, volume)'), - capabilities: z - .array(z.string()) - .optional() - .describe('Required vehicle capabilities'), - earliest_start: iso8601Schema - .optional() - .describe('Earliest operation start time'), - latest_end: iso8601Schema.optional().describe('Latest operation end time'), - breaks: z - .array(vehicleBreakSchema) - .optional() - .describe('Vehicle break requirements'), - loading_policy: z - .enum(['any', 'fifo', 'lifo']) - .optional() - .describe('Loading/unloading policy') -}); - -const serviceSchema = z.object({ - name: z.string().describe('Unique identifier for this service'), - location: z - .string() - .describe( - 'Location as a STRING name where service is performed. Use "location-0" for coordinates[0], "location-1" for coordinates[1], etc. (NOT integers like 0, 1, 2)' - ), - duration: z - .number() - .int() - .nonnegative() - .optional() - .default(0) - .describe('Service duration in seconds'), - requirements: z - .array(z.string()) - .optional() - .describe('Required vehicle capabilities'), - service_times: z - .array(timeWindowSchema) - .optional() - .describe('Time window constraints for service') -}); - -const shipmentSchema = z.object({ - name: z.string().describe('Unique identifier for this shipment'), - from: z - .string() - .describe( - 'Pickup location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' - ), - to: z - .string() - .describe( - 'Delivery location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' - ), - size: z - .record(z.number()) - .optional() - .describe('Capacity consumption (weight, volume, etc.)'), - requirements: z - .array(z.string()) - .optional() - .describe('Required vehicle capabilities'), - pickup_duration: z - .number() - .int() - .nonnegative() - .optional() - .default(0) - .describe('Pickup duration in seconds'), - dropoff_duration: z - .number() - .int() - .nonnegative() - .optional() - .default(0) - .describe('Dropoff duration in seconds'), - pickup_times: z - .array(timeWindowSchema) - .optional() - .describe('Time window constraints for pickup'), - dropoff_times: z - .array(timeWindowSchema) - .optional() - .describe('Time window constraints for dropoff') -}); - +/** + * Input schema for OptimizationTool (V1 API) + * + * The V1 Optimization API finds the optimal (shortest by travel time) route + * through a set of coordinates, solving the Traveling Salesman Problem. + */ export const OptimizationInputSchema = z.object({ coordinates: z .array(coordinateSchema) .min(2, 'At least 2 coordinates are required') - .max(1000, 'Maximum 1000 coordinates allowed') + .max(12, 'Maximum 12 coordinates allowed for V1 API') .describe( 'Array of {longitude, latitude} coordinate pairs to optimize a route through. ' + - 'Must include at least 2 coordinate pairs. ' + - 'Up to 1000 coordinates total are supported.' + 'The V1 API supports 2-12 coordinates and returns the optimal visiting order.' ), profile: profileSchema .optional() .default('mapbox/driving') .describe('Routing profile to use for optimization'), - vehicles: z - .array(vehicleSchema) + source: z + .enum(['any', 'first']) .optional() + .default('any') .describe( - 'Array of vehicle objects. If not provided, a default vehicle will be created automatically. ' + - 'IMPORTANT: If you provide vehicles, you MUST also provide either "services" or "shipments" to define the stops each vehicle should visit.' + 'Location to start the trip. "any" allows any coordinate, "first" forces the first coordinate as start.' ), - services: z - .array(serviceSchema) + destination: z + .enum(['any', 'last']) .optional() + .default('any') .describe( - 'Array of service objects representing individual stops/tasks (e.g., deliveries, pickups, visits). ' + - 'Each service is performed at a single location. Required when using custom vehicles.' + 'Location to end the trip. "any" allows any coordinate, "last" forces the last coordinate as end.' ), - shipments: z - .array(shipmentSchema) + roundtrip: z + .boolean() .optional() + .default(true) .describe( - 'Array of shipment objects representing paired pickup/delivery tasks. ' + - 'Each shipment has a pickup location and a delivery location. Can be used with or instead of services when using custom vehicles.' + 'Whether to return to the starting point. Set to false for one-way trips.' ), - options: optionsSchema.optional().describe('Optimization options'), - max_polling_attempts: z - .number() - .int() - .positive() - .optional() - .default(30) - .describe('Maximum number of polling attempts (default: 30)'), - polling_interval_ms: z - .number() - .int() - .positive() + geometries: z + .enum(['geojson', 'polyline', 'polyline6']) + .optional() + .default('geojson') + .describe('Format for route geometry'), + overview: z + .enum(['full', 'simplified', 'false']) + .optional() + .default('simplified') + .describe('Detail level of route geometry'), + steps: z + .boolean() + .optional() + .default(false) + .describe('Whether to include turn-by-turn instructions'), + annotations: z + .array(z.enum(['duration', 'distance', 'speed'])) + .optional() + .describe('Additional metadata to include for each route segment'), + language: z + .string() .optional() - .default(1000) - .describe('Polling interval in milliseconds (default: 1000)') + .describe( + 'Language for instructions (if steps=true). ISO 639-1 code (e.g., "en", "es").' + ) }); export type OptimizationInput = z.infer; diff --git a/src/tools/optimization-tool/OptimizationTool.output.schema.ts b/src/tools/optimization-tool/OptimizationTool.output.schema.ts index 99614f6..d1f6fa4 100644 --- a/src/tools/optimization-tool/OptimizationTool.output.schema.ts +++ b/src/tools/optimization-tool/OptimizationTool.output.schema.ts @@ -4,134 +4,94 @@ import { z } from 'zod'; /** - * Stop schema for route stops - * Made flexible to handle various API response formats + * Waypoint schema - snapped coordinates on the road network */ -const stopSchema = z +const waypointSchema = z .object({ - type: z - .string() - .describe( - 'Type of stop. Known values include "start" (vehicle begins), "service" (perform service), "pickup"/"dropoff" (shipment handling), "break" (vehicle break), "end" (vehicle finishes). Additional values may be returned as the API evolves.' - ), + name: z.string().optional().describe('Name of the road/path at this point'), location: z - .string() - .describe( - 'Location name for this stop (e.g., "location-0", "location-1")' - ), - eta: z - .string() - .optional() - .describe( - 'Estimated time of arrival in ISO 8601 format (e.g., "2023-07-22T14:29:23-07:00")' - ), - odometer: z + .tuple([z.number(), z.number()]) + .describe('Snapped coordinate as [longitude, latitude]'), + trips_index: z .number() - .optional() - .describe('Total distance traveled to reach this stop in meters'), - wait: z - .number() - .optional() - .describe('Wait time at this stop in seconds before proceeding'), - duration: z + .describe('Index of the trip this waypoint belongs to'), + waypoint_index: z .number() - .optional() - .describe('Duration of service/activity at this stop in seconds'), - services: z - .array(z.string()) - .optional() - .describe('Array of service names fulfilled at this stop'), - pickups: z - .array(z.string()) - .optional() - .describe('Array of shipment names picked up at this stop'), - dropoffs: z - .array(z.string()) - .optional() - .describe('Array of shipment names dropped off at this stop') + .describe('Position of this waypoint within its trip') }) - .passthrough(); // Allow additional fields from API + .passthrough(); /** - * Route schema + * Leg schema - segment between two waypoints */ -const routeSchema = z +const legSchema = z .object({ - vehicle: z + distance: z.number().describe('Distance for this leg in meters'), + duration: z.number().describe('Duration for this leg in seconds'), + steps: z + .array(z.any()) + .optional() + .describe('Turn-by-turn instructions (if steps=true)'), + summary: z .string() - .describe( - 'Vehicle name for this route (matches the vehicle name from input)' - ), - stops: z - .array(stopSchema) - .describe( - 'Ordered sequence of stops for this vehicle, from start to end. Includes all services, pickups, dropoffs, and breaks in optimized order.' - ) + .optional() + .describe('Summary of the leg (if available)'), + annotation: z + .object({ + duration: z.array(z.number()).optional(), + distance: z.array(z.number()).optional(), + speed: z.array(z.number()).optional() + }) + .optional() + .describe('Detailed annotations for the leg (if requested)') }) - .passthrough(); // Allow additional fields from API + .passthrough(); /** - * Dropped items schema + * Trip schema - the optimized route */ -const droppedSchema = z +const tripSchema = z .object({ - services: z - .array(z.string()) - .optional() + geometry: z + .union([z.string(), z.any()]) .describe( - 'Array of service names that could not be fulfilled due to constraints (e.g., time windows, capacity, capabilities)' + 'Route geometry as GeoJSON LineString or encoded polyline string' ), - shipments: z - .array(z.string()) + legs: z.array(legSchema).describe('Array of legs between waypoints'), + weight: z.number().describe('Weight value used in optimization'), + weight_name: z + .string() .optional() - .describe( - 'Array of shipment names that could not be fulfilled due to constraints (e.g., time windows, capacity, capabilities)' - ) + .describe('Name of weight type used (default: "routability")'), + duration: z.number().describe('Total trip duration in seconds'), + distance: z.number().describe('Total trip distance in meters') }) - .passthrough(); // Allow additional fields from API + .passthrough(); /** - * Output schema for OptimizationTool - * Uses passthrough to be flexible with API response variations + * Output schema for OptimizationTool (V1 API) + * + * Returns the optimized trip through all input coordinates. */ export const OptimizationOutputSchema = z .object({ - version: z - .number() - .optional() - .describe('API version number (always 1 for Optimization API v2)'), - dropped: droppedSchema - .optional() - .describe( - 'Items that could not be fulfilled in the optimization. If present, contains arrays of service/shipment names that were dropped.' - ), - routes: z - .array(routeSchema) - .optional() - .describe( - 'Array of optimized routes, one per vehicle. Each route contains the vehicle name and an ordered sequence of stops. May be undefined if optimization fails completely.' - ), - // Error response fields from API code: z .string() - .optional() + .describe('Status code (e.g., "Ok" for success, error code otherwise)'), + waypoints: z + .array(waypointSchema) .describe( - 'Error code from API (e.g., "internal_error"). Present only when the API returns an error response.' + 'Input coordinates snapped to the road network in optimized order' ), - message: z - .string() - .optional() + trips: z + .array(tripSchema) .describe( - 'Human-readable error message from API. Present only when the API returns an error response.' + 'Array containing the optimized trip (typically 1 trip for all waypoints)' ), - ref: z - .string() - .optional() - .describe( - 'Reference ID for the error from API. Present only when the API returns an error response.' - ) + // Error response fields + message: z.string().optional().describe('Error message if code is not "Ok"') }) - .passthrough(); // Allow additional fields from API + .passthrough(); /** * Type inference for OptimizationOutput diff --git a/src/tools/optimization-tool/OptimizationTool.ts b/src/tools/optimization-tool/OptimizationTool.ts index 368b02c..557e0af 100644 --- a/src/tools/optimization-tool/OptimizationTool.ts +++ b/src/tools/optimization-tool/OptimizationTool.ts @@ -1,305 +1,196 @@ // Copyright (c) Mapbox, Inc. // Licensed under the MIT License. -import type { z } from 'zod'; -import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; +import { SpanStatusCode } from '@opentelemetry/api'; import { MapboxApiBasedTool } from '../MapboxApiBasedTool.js'; -import type { HttpRequest } from '../../utils/types.js'; -import { OptimizationInputSchema } from './OptimizationTool.input.schema.js'; +import { + OptimizationInputSchema, + type OptimizationInput +} from './OptimizationTool.input.schema.js'; import { OptimizationOutputSchema, type OptimizationOutput } from './OptimizationTool.output.schema.js'; - -// API documentation: https://docs.mapbox.com/api/navigation/optimization/ +import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js'; +import type { ToolExecutionContext } from '../../utils/tracing.js'; +import type { HttpRequest } from '../../utils/types.js'; /** - * OptimizationTool - Solves vehicle routing problems using the Mapbox Optimization API v2. - * Supports complex routing scenarios with multiple vehicles, time windows, capacities, and shipments. + * OptimizationTool - Find optimal route through multiple coordinates (V1 API) + * + * Uses the Mapbox Optimization API V1 to solve the Traveling Salesman Problem + * and return the shortest route by travel time through a set of coordinates. */ export class OptimizationTool extends MapboxApiBasedTool< typeof OptimizationInputSchema, typeof OptimizationOutputSchema > { - name = 'optimization_tool'; - description = - 'Solves vehicle routing problems using the Mapbox Optimization API v2. ' + - 'Supports up to 1000 coordinates in {longitude, latitude} format. ' + - 'Returns optimized routes with stops, ETAs, and dropped items. ' + - '\n\n' + - 'USAGE MODES:\n' + - '1. SIMPLIFIED MODE (recommended for basic routing): Provide only "coordinates" and optionally "profile". ' + - 'The tool will automatically create a default vehicle that visits all locations in optimized order, ' + - 'starting and ending at the first coordinate.\n' + - '2. ADVANCED MODE (for complex scenarios): If you specify "vehicles", you MUST also provide either ' + - '"services" (single stops like deliveries or pickups) or "shipments" (paired pickup/dropoff tasks). ' + - 'Each service/shipment defines a stop that vehicles must visit.\n' + - '\n' + - 'KEY CONCEPTS:\n' + - '- "services": Individual stops at locations (e.g., deliver package to address A, pick up at coffee shop B)\n' + - '- "shipments": Paired pickup/delivery tasks (e.g., pick up from warehouse, deliver to customer)\n' + - '- "vehicles": Routing agents with optional constraints like time windows, capacities, and capabilities\n' + - '\n' + - 'LOCATION NAMING (CRITICAL):\n' + - 'The tool auto-generates STRING location names from your coordinates array as "location-0", "location-1", "location-2", etc. ' + - 'When creating services, shipments, or vehicles, you MUST reference these auto-generated STRINGS (NOT integers, NOT array indices):\n' + - '- coordinates[0] → use STRING "location-0" (NOT integer 0)\n' + - '\n' + - 'EXAMPLES:\n' + - '✓ CORRECT: service.location = "location-2" (string)\n' + - '✗ WRONG: service.location = 2 (integer)\n' + - '\n' + - 'OUTPUT FORMAT:\n' + - 'The tool returns a solution with:\n' + - '- "routes": Array of optimized routes, one per vehicle. Each route contains:\n' + - ' - "vehicle": The vehicle name\n' + - ' - "stops": Ordered array of stops with:\n' + - ' - "type": start, service, pickup, dropoff, break, or end\n' + - ' - "location": The location name (e.g., "location-0")\n' + - ' - "eta": Estimated time of arrival (ISO 8601 timestamp)\n' + - ' - "odometer": Total distance traveled in meters\n' + - ' - "wait": Wait time in seconds before proceeding\n' + - ' - "duration": Service time in seconds\n' + - ' - "services": Array of service names fulfilled at this stop\n' + - ' - "pickups"/"dropoffs": Arrays of shipment names handled\n' + - '- "dropped": Object with "services" and "shipments" arrays listing items that could not be fulfilled\n' + - '\n' + - 'WORKING WITH RESPONSES:\n' + - 'The tool returns structured data that you can access directly as an object/dictionary. ' + - 'DO NOT try to parse the response as a JSON string - access it as structured data instead. ' + - 'For large responses: (1) Access routes directly: result.routes[0], result.routes[1], etc. ' + - '(2) Iterate through routes: for route in result.routes. ' + - '(3) Access stop data: route.stops[i].location, route.stops[i].eta, etc. ' + - '(4) Extract only the fields you need rather than copying the entire response. ' + - 'NEVER use JSON.parse() or string manipulation on the response - the data is already structured and ready to use.\n' + - '\n' + - 'PRESENTING RESULTS TO USERS:\n' + - 'When sharing optimization results, ALWAYS present the route assignments. For each route, show: ' + - '(1) The vehicle name/ID. ' + - '(2) The complete ordered list of stops for that vehicle (by location name or service name). Include ALL routes. ' + - '(3) Key metrics like total distance, number of stops, and all ETAs. ' + - 'Example format: "Vehicle 1 route: Depot (location-0) → Coffee Shop A (location-1) → Coffee Shop B (location-5) → Depot (location-0). Total: 3 stops, 15.2 km." ' + - '\n' + - 'DISPLAYING ROUTES ON A MAP:\n' + - 'The optimization API returns the SEQUENCE of stops but NOT route geometries (line paths between stops). ' + - 'To draw routes on a map: (1) Extract the ordered stop locations from each route. ' + - '(2) For each consecutive pair of stops, use a routing/directions API to get the path geometry between them. ' + - '(3) Combine these geometries to visualize the complete route path. ' + - 'You can display stop markers immediately, but drawing connecting route lines requires additional routing API calls.\n' + - 'When building the map in the final_answer, include all the generated routes in a list like [vehicle1_route, vehicle2_route], and include all the stops as points on the map.' + - '\n' + - 'IMPORTANT: Coordinates must be {longitude, latitude} objects where longitude comes first.'; - annotations = { - title: 'Optimization Tool', + readonly name = 'optimization_tool'; + readonly description = + 'Find the optimal (shortest by travel time) route through a set of 2-12 coordinates. ' + + 'Solves the Traveling Salesman Problem to determine the best visiting order. ' + + 'Supports options for starting point, ending point, and whether to return to start.'; + + readonly annotations = { + title: 'Optimize Multi-Stop Route', readOnlyHint: true, destructiveHint: false, - idempotentHint: false, + idempotentHint: true, openWorldHint: true }; - constructor({ httpRequest }: { httpRequest: HttpRequest }) { + constructor(params: { httpRequest: HttpRequest }) { super({ inputSchema: OptimizationInputSchema, outputSchema: OptimizationOutputSchema, - httpRequest + httpRequest: params.httpRequest }); } - /** - * Execute the tool logic - * @param input - Validated input from OptimizationInputSchema - * @param accessToken - Mapbox access token - * @returns CallToolResult with structured output - */ protected async execute( - input: z.infer, - accessToken: string + input: OptimizationInput, + accessToken: string, + toolContext: ToolExecutionContext ): Promise { - // Validate: If vehicles are provided, at least one service or shipment is required - if (input.vehicles && input.vehicles.length > 0) { - const hasServices = input.services && input.services.length > 0; - const hasShipments = input.shipments && input.shipments.length > 0; - - if (!hasServices && !hasShipments) { - return { - content: [ - { - type: 'text', - text: JSON.stringify({ - error: - 'When vehicles are provided, at least one service or shipment is required' - }) - } - ], - isError: true - }; + try { + // Format coordinates for URL: "lon,lat;lon,lat;..." + const coordinatesStr = input.coordinates + .map((coord) => `${coord.longitude},${coord.latitude}`) + .join(';'); + + // Build query parameters + const params = new URLSearchParams({ + access_token: accessToken + }); + + if (input.source) { + params.set('source', input.source); } - } - - // Convert simplified input to Optimization API v2 format - // Create locations array with auto-generated names - const locations = input.coordinates.map((coord, index) => ({ - name: `location-${index}`, - coordinates: [coord.longitude, coord.latitude] as [number, number] - })); - - // If vehicles are not provided, create a default vehicle - let vehicles: Array; - let services: Array; - let shipments: Array | undefined; - - if (!input.vehicles || input.vehicles.length === 0) { - // Simplified mode: auto-generate vehicle and services from coordinates - vehicles = [ - { - name: 'vehicle-1', - routing_profile: input.profile, - start_location: 'location-0', // Start at first location - end_location: 'location-0' // Return to first location - } - ]; - - // Create services for all locations except the first (which is start/end) - services = input.coordinates.slice(1).map((_, index) => ({ - name: `service-${index + 1}`, - location: `location-${index + 1}`, - duration: 0 // No service time by default - })); - } else { - // Advanced mode: use provided vehicles, services, and shipments - vehicles = input.vehicles; - services = input.services || []; - shipments = input.shipments; - } - - // Build request body - const requestBody: { - version: number; - locations: Array<{ name: string; coordinates: [number, number] }>; - vehicles: Array; - services: Array; - shipments?: Array; - } = { - version: 1, - locations, - vehicles, - services - }; - - if (shipments && shipments.length > 0) { - requestBody.shipments = shipments; - } - - // Step 1: POST to create optimization job - const postUrl = `${MapboxApiBasedTool.mapboxApiEndpoint}optimized-trips/v2?access_token=${accessToken}`; - - const postResponse = await this.httpRequest(postUrl, { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify(requestBody) - }); - - if (!postResponse.ok) { - const errorText = await postResponse.text(); - let errorMessage = `Request failed with status ${postResponse.status}: ${postResponse.statusText}`; + if (input.destination) { + params.set('destination', input.destination); + } + params.set('roundtrip', String(input.roundtrip)); - try { - const errorJson = JSON.parse(errorText); - if (errorJson.message) { - errorMessage = `${errorMessage} - ${errorJson.message}`; - } - } catch { - // If parsing fails, use the raw text - if (errorText) { - errorMessage = `${errorMessage} - ${errorText}`; - } + if (input.geometries) { + params.set('geometries', input.geometries); + } + if (input.overview) { + params.set('overview', input.overview); + } + if (input.steps !== undefined) { + params.set('steps', String(input.steps)); + } + if (input.annotations && input.annotations.length > 0) { + params.set('annotations', input.annotations.join(',')); + } + if (input.language) { + params.set('language', input.language); } - return { - content: [{ type: 'text', text: errorMessage }], - isError: true - }; - } + // Build URL: GET /optimized-trips/v1/{profile}/{coordinates} + const url = `${MapboxApiBasedTool.mapboxApiEndpoint}optimized-trips/v1/${input.profile}/${coordinatesStr}?${params.toString()}`; - const postData = (await postResponse.json()) as { - id: string; - status: string; - }; - const jobId = postData.id; + toolContext.span.setAttribute( + 'optimization.coordinates_count', + input.coordinates.length + ); + toolContext.span.setAttribute('optimization.profile', input.profile); + toolContext.span.setAttribute('optimization.roundtrip', input.roundtrip); - // Step 2: Poll GET endpoint for results - const maxAttempts = input.max_polling_attempts ?? 10; - const pollingInterval = input.polling_interval_ms ?? 1000; - let attempts = 0; + // Make synchronous GET request + const response = await this.httpRequest(url); - while (attempts < maxAttempts) { - const getUrl = `${MapboxApiBasedTool.mapboxApiEndpoint}optimized-trips/v2/${jobId}?access_token=${accessToken}`; - const getResponse = await this.httpRequest(getUrl); + if (!response.ok) { + const errorText = await response.text(); + let errorMessage = `Request failed with status ${response.status}: ${response.statusText}`; - if (!getResponse.ok) { - if (getResponse.status === 404) { - return { - content: [ - { - type: 'text', - text: `Optimization job ${jobId} not found` - } - ], - isError: true - }; + try { + const errorJson = JSON.parse(errorText); + if (errorJson.message) { + errorMessage = `${errorMessage} - ${errorJson.message}`; + } + } catch { + if (errorText) { + errorMessage = `${errorMessage} - ${errorText}`; + } } - const errorMessage = `Request failed with status ${getResponse.status}: ${getResponse.statusText}`; + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); return { - content: [{ type: 'text', text: errorMessage }], + content: [{ type: 'text' as const, text: errorMessage }], isError: true }; } - // HTTP 200 means the optimization is complete - if (getResponse.status === 200) { - const result = (await getResponse.json()) as OptimizationOutput; + const data = (await response.json()) as OptimizationOutput; - // Validate the response against our output schema - try { - const validatedData = OptimizationOutputSchema.parse(result); + // Validate output + const validatedResult = this.validateOutput(data) as OptimizationOutput; - return { - content: [ - { type: 'text', text: JSON.stringify(validatedData, null, 2) } - ], - structuredContent: validatedData, - isError: false - }; - } catch (validationError) { - // If validation fails, return the raw result anyway with a warning - this.log( - 'warning', - `Schema validation warning: ${validationError instanceof Error ? validationError.message : String(validationError)}` - ); + // Check for API error in response + if (validatedResult.code !== 'Ok') { + const errorMsg = validatedResult.message || validatedResult.code; + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMsg + }); - return { - content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], - structuredContent: result, - isError: false - }; - } + return { + content: [ + { type: 'text' as const, text: `Optimization error: ${errorMsg}` } + ], + structuredContent: validatedResult, + isError: true + }; } - // HTTP 202 means still processing, wait and retry - await new Promise((resolve) => setTimeout(resolve, pollingInterval)); - attempts++; - } + // Format success response + const trip = validatedResult.trips[0]; + const durationMin = (trip.duration / 60).toFixed(1); + const distanceKm = (trip.distance / 1000).toFixed(2); + + const text = + `Optimized route through ${validatedResult.waypoints.length} waypoints:\n` + + `- Total duration: ${durationMin} minutes\n` + + `- Total distance: ${distanceKm} km\n` + + `- Optimized order: ${validatedResult.waypoints.map((_, i) => i).join(' → ')}`; + + toolContext.span.setAttribute( + 'optimization.duration_seconds', + trip.duration + ); + toolContext.span.setAttribute( + 'optimization.distance_meters', + trip.distance + ); + toolContext.span.setAttribute( + 'optimization.waypoints_count', + validatedResult.waypoints.length + ); - return { - content: [ - { - type: 'text', - text: `Optimization timed out after ${maxAttempts} attempts. Job ID: ${jobId}. You can check the status later using the job ID.` - } - ], - isError: true - }; + return { + content: [{ type: 'text' as const, text }], + structuredContent: validatedResult, + isError: false + }; + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : String(error); + toolContext.span.setStatus({ + code: SpanStatusCode.ERROR, + message: errorMessage + }); + this.log('error', `${this.name}: ${errorMessage}`); + return { + content: [ + { type: 'text' as const, text: `OptimizationTool: ${errorMessage}` } + ], + isError: true + }; + } } } diff --git a/src/tools/optimization-tool/OptimizationV2Tool.input.schema.ts b/src/tools/optimization-tool/OptimizationV2Tool.input.schema.ts new file mode 100644 index 0000000..dfbee32 --- /dev/null +++ b/src/tools/optimization-tool/OptimizationV2Tool.input.schema.ts @@ -0,0 +1,215 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import z from 'zod'; +import { coordinateSchema } from '../../schemas/shared.js'; + +// Profile schema (driving, walking, cycling, driving-traffic) +const profileSchema = z + .enum([ + 'mapbox/driving', + 'mapbox/walking', + 'mapbox/cycling', + 'mapbox/driving-traffic' + ]) + .describe('Routing profile'); + +/** + * Input schema for OptimizationV2Tool (V2 API - Beta) + * + * The V2 API is currently in beta and requires early access. + * Supports advanced features: time windows, capacity limits, vehicle capabilities, + * shipments, breaks, and more. + */ + +const optionsSchema = z.object({ + objectives: z + .array( + z.enum(['min-total-travel-duration', 'min-schedule-completion-time']) + ) + .optional() + .describe('Optimization objectives') +}); + +const iso8601Schema = z + .string() + .regex( + /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?([+-]\d{2}:\d{2}|Z)?$/, + 'Must be a valid ISO 8601 datetime string (e.g., 2023-07-22T14:29:23-07:00)' + ); + +const timeWindowSchema = z.object({ + earliest: iso8601Schema.describe('Earliest time for this window'), + latest: iso8601Schema.describe('Latest time for this window'), + type: z + .enum(['strict', 'soft', 'soft_start', 'soft_end']) + .optional() + .describe('Type of time window constraint') +}); + +const vehicleBreakSchema = z.object({ + earliest_start: iso8601Schema.describe('Earliest start time for break'), + latest_end: iso8601Schema.describe('Latest end time for break'), + duration: z.number().int().positive().describe('Break duration in seconds') +}); + +const vehicleSchema = z.object({ + name: z.string().describe('Unique identifier for this vehicle'), + routing_profile: profileSchema + .optional() + .describe('Routing profile for this vehicle'), + start_location: z + .string() + .optional() + .describe( + 'Starting location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' + ), + end_location: z + .string() + .optional() + .describe( + 'Ending location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' + ), + capacities: z + .record(z.number()) + .optional() + .describe('Custom capacity dimensions (e.g., weight, volume)'), + capabilities: z + .array(z.string()) + .optional() + .describe('Required vehicle capabilities'), + earliest_start: iso8601Schema + .optional() + .describe('Earliest operation start time'), + latest_end: iso8601Schema.optional().describe('Latest operation end time'), + breaks: z + .array(vehicleBreakSchema) + .optional() + .describe('Vehicle break requirements'), + loading_policy: z + .enum(['any', 'fifo', 'lifo']) + .optional() + .describe('Loading/unloading policy') +}); + +const serviceSchema = z.object({ + name: z.string().describe('Unique identifier for this service'), + location: z + .string() + .describe( + 'Location as a STRING name where service is performed. Use "location-0" for coordinates[0], "location-1" for coordinates[1], etc. (NOT integers like 0, 1, 2)' + ), + duration: z + .number() + .int() + .nonnegative() + .optional() + .default(0) + .describe('Service duration in seconds'), + requirements: z + .array(z.string()) + .optional() + .describe('Required vehicle capabilities'), + service_times: z + .array(timeWindowSchema) + .optional() + .describe('Time window constraints for service') +}); + +const shipmentSchema = z.object({ + name: z.string().describe('Unique identifier for this shipment'), + from: z + .string() + .describe( + 'Pickup location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' + ), + to: z + .string() + .describe( + 'Delivery location as a STRING name (e.g., "location-0" for coordinates[0], NOT the integer 0)' + ), + size: z + .record(z.number()) + .optional() + .describe('Capacity consumption (weight, volume, etc.)'), + requirements: z + .array(z.string()) + .optional() + .describe('Required vehicle capabilities'), + pickup_duration: z + .number() + .int() + .nonnegative() + .optional() + .default(0) + .describe('Pickup duration in seconds'), + dropoff_duration: z + .number() + .int() + .nonnegative() + .optional() + .default(0) + .describe('Dropoff duration in seconds'), + pickup_times: z + .array(timeWindowSchema) + .optional() + .describe('Time window constraints for pickup'), + dropoff_times: z + .array(timeWindowSchema) + .optional() + .describe('Time window constraints for dropoff') +}); + +export const OptimizationV2InputSchema = z.object({ + coordinates: z + .array(coordinateSchema) + .min(2, 'At least 2 coordinates are required') + .max(1000, 'Maximum 1000 coordinates allowed') + .describe( + 'Array of {longitude, latitude} coordinate pairs to optimize a route through. ' + + 'Must include at least 2 coordinate pairs. ' + + 'Up to 1000 coordinates total are supported.' + ), + profile: profileSchema + .optional() + .default('mapbox/driving') + .describe('Routing profile to use for optimization'), + vehicles: z + .array(vehicleSchema) + .optional() + .describe( + 'Array of vehicle objects. If not provided, a default vehicle will be created automatically. ' + + 'IMPORTANT: If you provide vehicles, you MUST also provide either "services" or "shipments" to define the stops each vehicle should visit.' + ), + services: z + .array(serviceSchema) + .optional() + .describe( + 'Array of service objects representing individual stops/tasks (e.g., deliveries, pickups, visits). ' + + 'Each service is performed at a single location. Required when using custom vehicles.' + ), + shipments: z + .array(shipmentSchema) + .optional() + .describe( + 'Array of shipment objects representing paired pickup/delivery tasks. ' + + 'Each shipment has a pickup location and a delivery location. Can be used with or instead of services when using custom vehicles.' + ), + options: optionsSchema.optional().describe('Optimization options'), + max_polling_attempts: z + .number() + .int() + .positive() + .optional() + .default(30) + .describe('Maximum number of polling attempts (default: 30)'), + polling_interval_ms: z + .number() + .int() + .positive() + .optional() + .default(1000) + .describe('Polling interval in milliseconds (default: 1000)') +}); + +export type OptimizationV2Input = z.infer; diff --git a/src/tools/optimization-tool/OptimizationV2Tool.output.schema.ts b/src/tools/optimization-tool/OptimizationV2Tool.output.schema.ts new file mode 100644 index 0000000..2c711cf --- /dev/null +++ b/src/tools/optimization-tool/OptimizationV2Tool.output.schema.ts @@ -0,0 +1,139 @@ +// Copyright (c) Mapbox, Inc. +// Licensed under the MIT License. + +import { z } from 'zod'; + +/** + * Stop schema for route stops + * Made flexible to handle various API response formats + */ +const stopSchema = z + .object({ + type: z + .string() + .describe( + 'Type of stop. Known values include "start" (vehicle begins), "service" (perform service), "pickup"/"dropoff" (shipment handling), "break" (vehicle break), "end" (vehicle finishes). Additional values may be returned as the API evolves.' + ), + location: z + .string() + .describe( + 'Location name for this stop (e.g., "location-0", "location-1")' + ), + eta: z + .string() + .optional() + .describe( + 'Estimated time of arrival in ISO 8601 format (e.g., "2023-07-22T14:29:23-07:00")' + ), + odometer: z + .number() + .optional() + .describe('Total distance traveled to reach this stop in meters'), + wait: z + .number() + .optional() + .describe('Wait time at this stop in seconds before proceeding'), + duration: z + .number() + .optional() + .describe('Duration of service/activity at this stop in seconds'), + services: z + .array(z.string()) + .optional() + .describe('Array of service names fulfilled at this stop'), + pickups: z + .array(z.string()) + .optional() + .describe('Array of shipment names picked up at this stop'), + dropoffs: z + .array(z.string()) + .optional() + .describe('Array of shipment names dropped off at this stop') + }) + .passthrough(); // Allow additional fields from API + +/** + * Route schema + */ +const routeSchema = z + .object({ + vehicle: z + .string() + .describe( + 'Vehicle name for this route (matches the vehicle name from input)' + ), + stops: z + .array(stopSchema) + .describe( + 'Ordered sequence of stops for this vehicle, from start to end. Includes all services, pickups, dropoffs, and breaks in optimized order.' + ) + }) + .passthrough(); // Allow additional fields from API + +/** + * Dropped items schema + */ +const droppedSchema = z + .object({ + services: z + .array(z.string()) + .optional() + .describe( + 'Array of service names that could not be fulfilled due to constraints (e.g., time windows, capacity, capabilities)' + ), + shipments: z + .array(z.string()) + .optional() + .describe( + 'Array of shipment names that could not be fulfilled due to constraints (e.g., time windows, capacity, capabilities)' + ) + }) + .passthrough(); // Allow additional fields from API + +/** + * Output schema for OptimizationV2Tool (V2 API - Beta) + * Uses passthrough to be flexible with API response variations + */ +export const OptimizationV2OutputSchema = z + .object({ + version: z + .number() + .optional() + .describe('API version number (always 1 for Optimization API v2)'), + dropped: droppedSchema + .optional() + .describe( + 'Items that could not be fulfilled in the optimization. If present, contains arrays of service/shipment names that were dropped.' + ), + routes: z + .array(routeSchema) + .optional() + .describe( + 'Array of optimized routes, one per vehicle. Each route contains the vehicle name and an ordered sequence of stops. May be undefined if optimization fails completely.' + ), + // Error response fields from API + code: z + .string() + .optional() + .describe( + 'Error code from API (e.g., "internal_error"). Present only when the API returns an error response.' + ), + message: z + .string() + .optional() + .describe( + 'Human-readable error message from API. Present only when the API returns an error response.' + ), + ref: z + .string() + .optional() + .describe( + 'Reference ID for the error from API. Present only when the API returns an error response.' + ) + }) + .passthrough(); // Allow additional fields from API + +/** + * Type inference for OptimizationV2Output + */ +export type OptimizationV2Output = z.infer; diff --git a/src/tools/optimization-tool/OptimizationTask.ts b/src/tools/optimization-tool/OptimizationV2Tool.ts similarity index 87% rename from src/tools/optimization-tool/OptimizationTask.ts rename to src/tools/optimization-tool/OptimizationV2Tool.ts index ed9de9e..643563b 100644 --- a/src/tools/optimization-tool/OptimizationTask.ts +++ b/src/tools/optimization-tool/OptimizationV2Tool.ts @@ -9,13 +9,29 @@ import type { CreateTaskRequestHandlerExtra, TaskRequestHandlerExtra } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js'; -import { OptimizationInputSchema } from './OptimizationTool.input.schema.js'; +import { OptimizationV2InputSchema } from './OptimizationV2Tool.input.schema.js'; import { - OptimizationOutputSchema, - type OptimizationOutput -} from './OptimizationTool.output.schema.js'; + OptimizationV2OutputSchema, + type OptimizationV2Output +} from './OptimizationV2Tool.output.schema.js'; -// API documentation: https://docs.mapbox.com/api/navigation/optimization/ +/** + * OptimizationV2Tool - Advanced route optimization using Mapbox Optimization API V2 (BETA) + * + * ⚠️ IMPORTANT: This tool uses the V2 API which is currently in beta and requires early access. + * The tool is not registered by default. To enable it, add it to the toolRegistry. + * + * V2 Features: + * - Time window constraints for services and shipments + * - Vehicle capacity limits for multiple resource types + * - Driver shifts with earliest start and latest end times + * - Pickup and dropoff constraints for shipment handling + * - Vehicle capabilities requirements (e.g., refrigeration, ladder) + * - Loading policies (FIFO, LIFO, or any order) + * - Mandated breaks for vehicles + * + * API documentation: https://docs.mapbox.com/api/navigation/optimization/ + */ /** * Helper function to validate JWT format @@ -37,7 +53,7 @@ function getMapboxApiEndpoint(): string { * Core function to submit optimization job to Mapbox API */ async function submitOptimizationJob( - input: z.infer, + input: z.infer, accessToken: string, httpRequest: HttpRequest ): Promise<{ jobId: string; status: string }> { @@ -153,7 +169,7 @@ async function pollOptimizationJob( jobId: string, accessToken: string, httpRequest: HttpRequest -): Promise<{ status: number; data?: OptimizationOutput; error?: string }> { +): Promise<{ status: number; data?: OptimizationV2Output; error?: string }> { const getUrl = `${getMapboxApiEndpoint()}optimized-trips/v2/${jobId}?access_token=${accessToken}`; const getResponse = await httpRequest(getUrl); @@ -173,7 +189,7 @@ async function pollOptimizationJob( // HTTP 200 means the optimization is complete if (getResponse.status === 200) { - const result = (await getResponse.json()) as OptimizationOutput; + const result = (await getResponse.json()) as OptimizationV2Output; return { status: 200, data: result @@ -211,7 +227,9 @@ async function backgroundPollOptimizationJob( if (pollResult.status === 200 && pollResult.data) { // Job completed successfully try { - const validatedData = OptimizationOutputSchema.parse(pollResult.data); + const validatedData = OptimizationV2OutputSchema.parse( + pollResult.data + ); await taskStore.storeTaskResult(taskId, 'completed', { content: [ @@ -276,18 +294,21 @@ async function backgroundPollOptimizationJob( } /** - * Register the Optimization tool as a task-based tool + * Register the Optimization V2 tool as a task-based tool + * + * ⚠️ BETA: This tool uses the V2 API which requires early access. + * Not registered by default - call this function manually to enable. */ -export function registerOptimizationTask( +export function registerOptimizationV2Task( server: McpServer, httpRequest: HttpRequest ): void { server.experimental.tasks.registerToolTask( - 'optimization_tool', + 'optimization_v2_tool', { - title: 'Optimization Tool', + title: 'Optimization Tool V2 (Beta)', description: - 'Solves vehicle routing problems using the Mapbox Optimization API v2. ' + + 'Solves vehicle routing problems using the Mapbox Optimization API v2 (Beta). ' + 'This is a long-running async task that submits an optimization job and polls for results. ' + 'Supports up to 1000 coordinates in {longitude, latitude} format. ' + 'Returns optimized routes with stops, ETAs, and dropped items. ' + @@ -315,8 +336,8 @@ export function registerOptimizationTask( '✗ WRONG: service.location = 2 (integer)\n' + '\n' + 'IMPORTANT: This is an async task. The task will start immediately but results will be available later via task polling.', - inputSchema: OptimizationInputSchema, - outputSchema: OptimizationOutputSchema, + inputSchema: OptimizationV2InputSchema, + outputSchema: OptimizationV2OutputSchema, annotations: { title: 'Optimization Tool', readOnlyHint: true, @@ -328,7 +349,7 @@ export function registerOptimizationTask( { async createTask(args: unknown, extra: CreateTaskRequestHandlerExtra) { // Validate input - const input = OptimizationInputSchema.parse(args); + const input = OptimizationV2InputSchema.parse(args); // Get and validate access token (from environment only for now) const accessToken = diff --git a/test/tools/optimization-tool/OptimizationTool.test.ts b/test/tools/optimization-tool/OptimizationTool.test.ts index 482e2a6..1329742 100644 --- a/test/tools/optimization-tool/OptimizationTool.test.ts +++ b/test/tools/optimization-tool/OptimizationTool.test.ts @@ -6,139 +6,67 @@ process.env.MAPBOX_ACCESS_TOKEN = import { describe, it, expect, afterEach, vi } from 'vitest'; import { setupHttpRequest } from '../../utils/httpPipelineUtils.js'; -import { - HttpPipeline, - UserAgentPolicy -} from '../../../src/utils/httpPipeline.js'; -import { OptimizationTool } from '../../../src/tools/optimization-tool/OptimizationTool.js'; -const sampleOptimizationJobResponse = { - id: 'test-job-123', - status: 'processing' -}; +import { OptimizationTool } from '../../../src/tools/optimization-tool/OptimizationTool.js'; -const sampleOptimizationResultResponse = { - routes: [ +// Sample V1 API response +const sampleV1Response = { + code: 'Ok', + waypoints: [ { - vehicle: 'vehicle-1', - stops: [ - { - type: 'start', - location: 'location-0', - eta: '2024-01-01T10:00:00Z', - odometer: 0, - wait: 0, - duration: 0 - }, - { - type: 'service', - location: 'location-1', - eta: '2024-01-01T10:05:00Z', - odometer: 1500, - wait: 0, - duration: 300, - services: ['service-1'] - }, - { - type: 'service', - location: 'location-2', - eta: '2024-01-01T10:12:00Z', - odometer: 3200, - wait: 0, - duration: 300, - services: ['service-2'] - }, - { - type: 'end', - location: 'location-0', - eta: '2024-01-01T10:20:00Z', - odometer: 5000, - wait: 0, - duration: 0 - } - ] + name: 'Market Street', + location: [-122.4194, 37.7749], + trips_index: 0, + waypoint_index: 0 + }, + { + name: 'Mission Street', + location: [-122.4195, 37.775], + trips_index: 0, + waypoint_index: 1 + }, + { + name: 'Valencia Street', + location: [-122.4197, 37.7751], + trips_index: 0, + waypoint_index: 2 } ], - dropped: { - services: [], - shipments: [] - } -}; - -// Helper function to create mock httpRequest with polling behavior -function createMockWithPolling( - postResponse: unknown, - getResponse: unknown | ((callNum: number) => unknown) -) { - const mockHttpRequest = vi.fn(); - let callCount = 0; - - mockHttpRequest.mockImplementation(() => { - callCount++; - // First call: POST to create job - if (callCount === 1) { - return Promise.resolve({ - ok: true, - status: 200, - json: async () => postResponse - }); + trips: [ + { + geometry: { + coordinates: [ + [-122.4194, 37.7749], + [-122.4195, 37.775], + [-122.4197, 37.7751], + [-122.4194, 37.7749] + ], + type: 'LineString' + }, + legs: [ + { distance: 150.2, duration: 45.1 }, + { distance: 200.3, duration: 60.2 }, + { distance: 250.4, duration: 75.3 } + ], + weight: 180.6, + weight_name: 'routability', + duration: 180.6, + distance: 600.9 } - // Subsequent calls: GET polling - const response = - typeof getResponse === 'function' ? getResponse(callCount) : getResponse; - return Promise.resolve(response); - }); - - const pipeline = new HttpPipeline(mockHttpRequest); - const userAgent = 'TestServer/1.0.0 (default, no-tag, abcdef)'; - pipeline.usePolicy(new UserAgentPolicy(userAgent)); - - return { - httpRequest: pipeline.execute.bind(pipeline), - mockHttpRequest - }; -} + ] +}; -describe('OptimizationTool', () => { +describe('OptimizationTool V1 API', () => { afterEach(() => { - vi.restoreAllMocks(); + vi.clearAllMocks(); }); - it('sends custom header', async () => { - const { httpRequest, mockHttpRequest } = createMockWithPolling( - sampleOptimizationJobResponse, - { - ok: true, - status: 200, - json: async () => sampleOptimizationResultResponse - } - ); - - await new OptimizationTool({ httpRequest }).run({ - coordinates: [ - { longitude: -122.4194, latitude: 37.7749 }, - { longitude: -122.4195, latitude: 37.775 }, - { longitude: -122.4197, latitude: 37.7751 } - ] - }); - - // OptimizationTool makes 2 calls (POST + GET polling), verify headers on both - expect(mockHttpRequest).toHaveBeenCalledTimes(2); - const firstCallArgs = mockHttpRequest.mock.calls[0]; - expect(firstCallArgs[1]?.headers).toMatchObject({ - 'User-Agent': expect.any(String) + it('should successfully optimize route with minimal input', async () => { + const { httpRequest, mockHttpRequest } = setupHttpRequest({ + ok: true, + status: 200, + json: async () => sampleV1Response }); - }); - - it('works in simplified mode with default vehicle', async () => { - const { httpRequest, mockHttpRequest } = createMockWithPolling( - sampleOptimizationJobResponse, - { - ok: true, - status: 200, - json: async () => sampleOptimizationResultResponse - } - ); const tool = new OptimizationTool({ httpRequest }); const result = await tool.run({ @@ -146,256 +74,143 @@ describe('OptimizationTool', () => { { longitude: -122.4194, latitude: 37.7749 }, { longitude: -122.4195, latitude: 37.775 }, { longitude: -122.4197, latitude: 37.7751 } - ], - profile: 'mapbox/driving' + ] }); expect(result.isError).toBe(false); - expect(result.structuredContent).toBeDefined(); - - // Verify POST request body includes auto-generated locations and vehicle - const firstCall = mockHttpRequest.mock.calls[0]; - const postBody = JSON.parse((firstCall[1] as { body: string }).body); - - // Verify using V1 API format - expect(postBody.version).toBe(1); - - expect(postBody.locations).toHaveLength(3); - expect(postBody.locations[0].name).toBe('location-0'); - expect(postBody.vehicles).toHaveLength(1); - expect(postBody.vehicles[0].name).toBe('vehicle-1'); - expect(postBody.vehicles[0].start_location).toBe('location-0'); - expect(postBody.vehicles[0].end_location).toBe('location-0'); - - // In simplified mode, services are created for all locations except first - expect(postBody.services).toHaveLength(2); - expect(postBody.services[0].name).toBe('service-1'); - expect(postBody.services[0].location).toBe('location-1'); - }); + expect(result.structuredContent).toMatchObject({ + code: 'Ok', + waypoints: expect.any(Array), + trips: expect.any(Array) + }); - it('works in advanced mode with custom vehicles and services', async () => { - const { httpRequest, mockHttpRequest } = createMockWithPolling( - sampleOptimizationJobResponse, - { - ok: true, - status: 200, - json: async () => sampleOptimizationResultResponse - } + // Verify URL format: GET /optimized-trips/v1/{profile}/{coordinates} + const callUrl = mockHttpRequest.mock.calls[0][0] as string; + expect(callUrl).toContain('optimized-trips/v1/mapbox/driving/'); + expect(callUrl).toContain( + '-122.4194,37.7749;-122.4195,37.775;-122.4197,37.7751' ); + expect(callUrl).toContain('roundtrip=true'); + }); + + it('should handle custom profile', async () => { + const { httpRequest, mockHttpRequest } = setupHttpRequest({ + ok: true, + status: 200, + json: async () => sampleV1Response + }); const tool = new OptimizationTool({ httpRequest }); - const result = await tool.run({ + await tool.run({ coordinates: [ { longitude: -122.4194, latitude: 37.7749 }, { longitude: -122.4195, latitude: 37.775 } ], - vehicles: [ - { - name: 'custom-vehicle', - routing_profile: 'mapbox/driving', - start_location: 'location-0', - end_location: 'location-0' - } - ], - services: [ - { - name: 'custom-service', - location: 'location-1', - duration: 300 - } - ] + profile: 'mapbox/cycling' }); - expect(result.isError).toBe(false); - - const firstCall = mockHttpRequest.mock.calls[0]; - const postBody = JSON.parse((firstCall[1] as { body: string }).body); - - expect(postBody.vehicles[0].name).toBe('custom-vehicle'); - expect(postBody.services[0].name).toBe('custom-service'); + const callUrl = mockHttpRequest.mock.calls[0][0] as string; + expect(callUrl).toContain('optimized-trips/v1/mapbox/cycling/'); }); - it('works with shipments instead of services', async () => { - const shipmentResponse = { - ...sampleOptimizationResultResponse, - routes: [ - { - vehicle: 'vehicle-1', - stops: [ - { - type: 'start', - location: 'location-0', - eta: '2024-01-01T10:00:00Z', - odometer: 0, - wait: 0, - duration: 0 - }, - { - type: 'pickup', - location: 'location-1', - eta: '2024-01-01T10:05:00Z', - odometer: 1500, - wait: 0, - duration: 300, - pickups: ['shipment-1'] - }, - { - type: 'dropoff', - location: 'location-2', - eta: '2024-01-01T10:12:00Z', - odometer: 3200, - wait: 0, - duration: 300, - dropoffs: ['shipment-1'] - }, - { - type: 'end', - location: 'location-0', - eta: '2024-01-01T10:20:00Z', - odometer: 5000, - wait: 0, - duration: 0 - } - ] - } - ] - }; - - const { httpRequest, mockHttpRequest } = createMockWithPolling( - sampleOptimizationJobResponse, - { - ok: true, - status: 200, - json: async () => shipmentResponse - } - ); + it('should handle source and destination options', async () => { + const { httpRequest, mockHttpRequest } = setupHttpRequest({ + ok: true, + status: 200, + json: async () => sampleV1Response + }); const tool = new OptimizationTool({ httpRequest }); - const result = await tool.run({ + await tool.run({ coordinates: [ { longitude: -122.4194, latitude: 37.7749 }, { longitude: -122.4195, latitude: 37.775 }, { longitude: -122.4197, latitude: 37.7751 } ], - vehicles: [ - { - name: 'delivery-vehicle', - routing_profile: 'mapbox/driving', - start_location: 'location-0', - end_location: 'location-0' - } - ], - shipments: [ - { - name: 'shipment-1', - from: 'location-1', - to: 'location-2', - pickup_duration: 300, - dropoff_duration: 300 - } - ] + source: 'first', + destination: 'last', + roundtrip: false }); - expect(result.isError).toBe(false); - - const firstCall = mockHttpRequest.mock.calls[0]; - const postBody = JSON.parse((firstCall[1] as { body: string }).body); - - expect(postBody.shipments).toHaveLength(1); - expect(postBody.shipments[0].name).toBe('shipment-1'); - expect(postBody.shipments[0].from).toBe('location-1'); - expect(postBody.shipments[0].to).toBe('location-2'); + const callUrl = mockHttpRequest.mock.calls[0][0] as string; + expect(callUrl).toContain('source=first'); + expect(callUrl).toContain('destination=last'); + expect(callUrl).toContain('roundtrip=false'); }); - it('returns error when vehicles provided without services or shipments', async () => { - const { httpRequest } = setupHttpRequest(); + it('should handle optional parameters (geometries, overview, steps)', async () => { + const { httpRequest, mockHttpRequest } = setupHttpRequest({ + ok: true, + status: 200, + json: async () => sampleV1Response + }); const tool = new OptimizationTool({ httpRequest }); - const result = await tool.run({ + await tool.run({ coordinates: [ { longitude: -122.4194, latitude: 37.7749 }, { longitude: -122.4195, latitude: 37.775 } ], - vehicles: [ - { - name: 'vehicle-1', - routing_profile: 'mapbox/driving', - start_location: 'location-0', - end_location: 'location-0' - } - ] - // Missing services or shipments + geometries: 'polyline', + overview: 'full', + steps: true, + annotations: ['duration', 'distance'] }); - expect(result.isError).toBe(true); - expect(result.content[0]).toMatchObject({ - type: 'text', - text: expect.stringContaining( - 'at least one service or shipment is required' - ) - }); + const callUrl = mockHttpRequest.mock.calls[0][0] as string; + expect(callUrl).toContain('geometries=polyline'); + expect(callUrl).toContain('overview=full'); + expect(callUrl).toContain('steps=true'); + expect(callUrl).toContain('annotations=duration%2Cdistance'); }); - it('handles polling timeout', async () => { - const { httpRequest } = createMockWithPolling( - sampleOptimizationJobResponse, - { - ok: true, - status: 202, - json: async () => ({ status: 'processing' }) - } - ); + it('should validate minimum coordinates (2)', async () => { + const { httpRequest } = setupHttpRequest({ + ok: true, + status: 200, + json: async () => sampleV1Response + }); const tool = new OptimizationTool({ httpRequest }); const result = await tool.run({ - coordinates: [ - { longitude: -122.4194, latitude: 37.7749 }, - { longitude: -122.4195, latitude: 37.775 } - ], - max_polling_attempts: 2, - polling_interval_ms: 10 + coordinates: [{ longitude: -122.4194, latitude: 37.7749 }] }); expect(result.isError).toBe(true); - expect(result.content[0]).toMatchObject({ - type: 'text', - text: expect.stringContaining('timed out after 2 attempts') - }); + expect(result.content[0].text).toContain( + 'At least 2 coordinates are required' + ); }); - it('handles API error on POST', async () => { + it('should validate maximum coordinates (12)', async () => { const { httpRequest } = setupHttpRequest({ - ok: false, - status: 400, - statusText: 'Bad Request', - text: async () => - JSON.stringify({ message: 'Invalid coordinates provided' }) + ok: true, + status: 200, + json: async () => sampleV1Response }); const tool = new OptimizationTool({ httpRequest }); - const result = await tool.run({ - coordinates: [ - { longitude: -122.4194, latitude: 37.7749 }, - { longitude: -122.4195, latitude: 37.775 } - ] - }); + const coords = Array.from({ length: 13 }, (_, i) => ({ + longitude: -122.4194 + i * 0.01, + latitude: 37.7749 + i * 0.01 + })); + + const result = await tool.run({ coordinates: coords }); expect(result.isError).toBe(true); - expect(result.content[0]).toMatchObject({ - type: 'text', - text: expect.stringContaining('Invalid coordinates provided') - }); + expect(result.content[0].text).toContain('Maximum 12 coordinates allowed'); }); - it('handles 404 on polling GET', async () => { - const { httpRequest } = createMockWithPolling( - sampleOptimizationJobResponse, - { - ok: false, - status: 404, - statusText: 'Not Found' - } - ); + it('should handle API errors gracefully', async () => { + const { httpRequest } = setupHttpRequest({ + ok: false, + status: 422, + statusText: 'Unprocessable Entity', + text: async () => + JSON.stringify({ + message: 'Invalid coordinates' + }) + }); const tool = new OptimizationTool({ httpRequest }); const result = await tool.run({ @@ -406,76 +221,54 @@ describe('OptimizationTool', () => { }); expect(result.isError).toBe(true); - expect(result.content[0]).toMatchObject({ - type: 'text', - text: expect.stringContaining('not found') - }); + expect(result.content[0].text).toContain('422'); + expect(result.content[0].text).toContain('Invalid coordinates'); }); - it('uses correct routing profile', async () => { - let callCount = 0; - const { httpRequest, mockHttpRequest } = setupHttpRequest(() => { - callCount++; - if (callCount === 1) { - return { - ok: true, - status: 200, - json: async () => sampleOptimizationJobResponse - }; - } - return { - ok: true, - status: 200, - json: async () => sampleOptimizationResultResponse - }; + it('should handle API error codes in response', async () => { + const { httpRequest } = setupHttpRequest({ + ok: true, + status: 200, + json: async () => ({ + code: 'NoRoute', + message: 'No route found between coordinates' + }) }); const tool = new OptimizationTool({ httpRequest }); - await tool.run({ + const result = await tool.run({ coordinates: [ { longitude: -122.4194, latitude: 37.7749 }, { longitude: -122.4195, latitude: 37.775 } - ], - profile: 'mapbox/cycling' + ] }); - const firstCall = mockHttpRequest.mock.calls[0]; - const postBody = JSON.parse((firstCall[1] as { body: string }).body); - - expect(postBody.vehicles[0].routing_profile).toBe('mapbox/cycling'); + expect(result.isError).toBe(true); + expect(result.content[0].text).toContain('No route found'); }); - it('includes structured content in successful response', async () => { - const { httpRequest } = createMockWithPolling( - sampleOptimizationJobResponse, - { - ok: true, - status: 200, - json: async () => sampleOptimizationResultResponse - } - ); + it('should format output text with duration and distance', async () => { + const { httpRequest } = setupHttpRequest({ + ok: true, + status: 200, + json: async () => sampleV1Response + }); const tool = new OptimizationTool({ httpRequest }); const result = await tool.run({ coordinates: [ { longitude: -122.4194, latitude: 37.7749 }, - { longitude: -122.4195, latitude: 37.775 } + { longitude: -122.4195, latitude: 37.775 }, + { longitude: -122.4197, latitude: 37.7751 } ] }); expect(result.isError).toBe(false); - expect(result.structuredContent).toBeDefined(); - expect(result.structuredContent).toMatchObject({ - routes: expect.arrayContaining([ - expect.objectContaining({ - vehicle: expect.any(String), - stops: expect.any(Array) - }) - ]), - dropped: expect.objectContaining({ - services: expect.any(Array), - shipments: expect.any(Array) - }) - }); + const text = result.content[0].text; + expect(text).toContain('Optimized route'); + expect(text).toContain('3 waypoints'); + expect(text).toContain('minutes'); + expect(text).toContain('km'); + expect(text).toContain('0 → 1 → 2'); }); });