From 271ac079526313284996c7ff1597157f5a117674 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:10:52 -0400 Subject: [PATCH 01/20] docs: add Electron desktop client design spec --- .gitignore | 1 + ...26-04-01-electron-desktop-client-design.md | 274 ++++++++++++++++++ 2 files changed, 275 insertions(+) create mode 100644 docs/specs/2026-04-01-electron-desktop-client-design.md diff --git a/.gitignore b/.gitignore index 107eddc10..9c4286afe 100644 --- a/.gitignore +++ b/.gitignore @@ -29,3 +29,4 @@ packages/cli/src/config/system-prompt.precompiled.ts .python-version 01-landing.png .playwright-cli/ +.superpowers/ diff --git a/docs/specs/2026-04-01-electron-desktop-client-design.md b/docs/specs/2026-04-01-electron-desktop-client-design.md new file mode 100644 index 000000000..31189ccf5 --- /dev/null +++ b/docs/specs/2026-04-01-electron-desktop-client-design.md @@ -0,0 +1,274 @@ +# Electron Desktop Client — Design Spec + +**Date:** 2026-04-01 +**Status:** Draft +**Package:** `packages/desktop` + +--- + +## Overview + +A native macOS desktop application that wraps PizzaPi into a self-contained experience. Users launch the app and get a fully working PizzaPi environment — relay server, runner daemon, and web UI — without touching a terminal. + +The Electron main process orchestrates child processes (relay server, runner daemon) and provides native OS integration (system tray, notifications, auto-launch). The renderer loads the existing `@pizzapi/ui` web app in a BrowserWindow, unchanged. + +## Goals + +- **Self-contained**: launch the app, everything starts automatically +- **Zero UI duplication**: renderer IS the existing web UI +- **Native feel**: system tray, OS notifications, login item +- **macOS first**: target macOS (arm64) for v1, expand later + +## Non-Goals (v1) + +- Windows or Linux support +- Bundled Redis (user must have Redis installed) +- Custom desktop-specific UI modifications +- Auto-updates or code signing +- Global hotkeys or deep links (pizzapi:// protocol) + +--- + +## Architecture + +### Process Model + +Four processes at runtime: + +| Process | Role | Implementation | +|---------|------|----------------| +| **Main** | App lifecycle, window management, tray, IPC | Electron main process (Node.js) | +| **Renderer** | Web UI | BrowserWindow loading `@pizzapi/ui` | +| **Relay Server** | HTTP + WebSocket relay, auth, sessions | `child_process.fork()` running `@pizzapi/server` | +| **Runner Daemon** | Agent execution | `child_process.spawn()` running `pizzapi runner` | + +### Startup Sequence + +1. `app.whenReady()` fires +2. Check Redis connectivity (fail with dialog if unavailable) +3. Spawn relay server on `localhost:3001` (or next available port) +4. Health-check the server (poll `/api/health` until 200) +5. Spawn runner daemon, connecting to the local relay +6. Create BrowserWindow, load UI pointing at `localhost:3001` +7. Initialize system tray with status indicators +8. Register IPC handlers + +### Shutdown Sequence + +1. User clicks Quit (or Cmd+Q) +2. Send SIGTERM to runner daemon, wait up to 5s +3. Send SIGTERM to relay server, wait up to 5s +4. Force-kill any remaining child processes +5. `app.quit()` + +### Window Behavior + +- Closing the window hides it (app stays in tray), doesn't quit +- Cmd+Q or tray "Quit" actually exits +- Window state (size, position) persisted via `electron-window-state` or manual `localStorage` + +--- + +## Package Structure + +``` +packages/desktop/ +├── package.json +├── electron-builder.yml +├── tsconfig.json +└── src/ + ├── main/ + │ ├── index.ts ← app entry, window creation + │ ├── server-manager.ts ← spawn/stop relay server + │ ├── runner-manager.ts ← spawn/stop runner daemon + │ ├── tray.ts ← system tray icon + menu + │ ├── notifications.ts ← native OS notifications + │ ├── auto-launch.ts ← login item registration + │ └── ipc.ts ← IPC handlers (main↔renderer) + └── preload/ + └── index.ts ← contextBridge exposing safe APIs +``` + +--- + +## Native OS Features + +### System Tray + +- **Tray icon**: Pizza emoji or custom icon, color-coded by status: + - Green: all services healthy + - Yellow: starting or degraded + - Red: error (server crashed, Redis down) +- **Click**: toggles window visibility +- **Context menu**: + - Show Window + - New Session + - ─── (separator) + - Server: localhost:3001 ✓ (status indicator) + - Runner: Connected ✓ + - Redis: Connected ✓ + - ─── (separator) + - Preferences… + - Quit PizzaPi + +### Native Notifications + +Delivered via Electron's `Notification` API. Three notification types: + +| Event | Title | Body | Click Action | +|-------|-------|------|-------------| +| Session complete | "Session Complete" | Agent finished task "{name}" in {duration} | Focus window, navigate to session | +| Agent needs input | "Agent Needs Input" | Session "{name}" is waiting for your response | Focus window, navigate to session | +| Service error | "Service Error" | {error description} | Focus window | + +Notifications are triggered by listening to the relay server's Socket.IO events from the main process. + +### Auto-Launch + +- Uses `app.setLoginItemSettings({ openAtLogin: true, openAsHidden: true })` on macOS +- Launches minimized to tray (no window shown) +- Toggled via a setting in tray Preferences or a future settings page +- Persisted in Electron's `app.getPath('userData')` config + +--- + +## Dev Workflow + +### Development Mode + +```bash +bun run dev:desktop +``` + +Uses `concurrently` to run: +1. Vite dev server (`packages/ui`) → `localhost:5173` +2. Relay server (`packages/server`) → `localhost:3001` +3. Electron main process with `--dev` flag + +In dev mode: +- BrowserWindow loads `http://localhost:5173` (Vite HMR) +- Vite proxies `/api` and `/socket.io` to `localhost:3001` +- Main process TypeScript compiled on-the-fly by Electron (via `tsx` or `electron-vite`) + +### Production Build + +```bash +bun run build:desktop +``` + +Steps: +1. Build `packages/ui` → `dist/` (static assets) +2. Build `packages/server` → `dist/` (compiled server) +3. Build `packages/cli` → `dist/` (runner daemon) +4. Compile `packages/desktop/src/main` → JS +5. `electron-builder` packages everything into `PizzaPi.app` + +In production mode: +- BrowserWindow loads UI assets from bundled `packages/ui/dist` +- Main process spawns server from bundled `packages/server/dist` +- Runner uses bundled `packages/cli/dist` + +### New Root Scripts + +```json +{ + "dev:desktop": "cd packages/desktop && bun run dev", + "build:desktop": "bun run build:ui && bun run build:server && bun run build:cli && cd packages/desktop && bun run build", + "package:desktop": "cd packages/desktop && bun run package" +} +``` + +--- + +## Dependencies + +### Runtime +- `electron` — app runtime + +### Dev / Build +- `electron-builder` — packaging into `.app` / `.dmg` +- `electron-log` — structured logging for main process + +### Workspace Dependencies +- `@pizzapi/ui` — renderer content (built assets) +- `@pizzapi/server` — relay server (spawned as child process) +- `@pizzapi/cli` — runner daemon (spawned as child process) +- `@pizzapi/protocol` — shared types for Socket.IO events + +--- + +## IPC Contract + +The preload script exposes a minimal API via `contextBridge`: + +```typescript +interface DesktopAPI { + // App info + getVersion(): string; + getPlatform(): string; + + // Service status + onServiceStatus(callback: (status: ServiceStatus) => void): void; + + // Window controls + minimizeToTray(): void; + + // Settings + getAutoLaunch(): Promise; + setAutoLaunch(enabled: boolean): Promise; +} + +interface ServiceStatus { + server: 'starting' | 'running' | 'error' | 'stopped'; + runner: 'starting' | 'running' | 'error' | 'stopped'; + redis: 'connected' | 'disconnected'; +} +``` + +The renderer doesn't need to call most of these directly — the existing UI already connects to the server via Socket.IO. The IPC layer is primarily for desktop-specific features (tray status, auto-launch toggle). + +--- + +## Error Handling + +| Scenario | Behavior | +|----------|----------| +| Redis not available | Show dialog: "Redis is required. Please install and start Redis." with link to install instructions. Don't start server. | +| Server crashes | Tray goes red. Notification: "Server crashed — restarting…". Auto-restart up to 3 times, then show error dialog. | +| Runner crashes | Tray shows degraded. Notification: "Runner disconnected — restarting…". Auto-restart up to 3 times. | +| Port 3001 in use | Try next available port (3002, 3003…). Pass port to UI via query param or env. | +| Electron crash | Standard Electron crash reporter. Log to `~/Library/Logs/PizzaPi/`. | + +--- + +## File Locations (macOS) + +| Purpose | Path | +|---------|------| +| App data | `~/Library/Application Support/PizzaPi/` | +| Logs | `~/Library/Logs/PizzaPi/` | +| Config | `~/.pizzapi/config.json` (shared with CLI) | +| Database | `~/Library/Application Support/PizzaPi/auth.db` | + +--- + +## Testing Strategy + +- **Unit tests**: server-manager, runner-manager lifecycle logic (spawn, health-check, restart, shutdown) +- **Integration tests**: full startup/shutdown sequence with mocked child processes +- **Manual testing**: tray behavior, notifications, auto-launch, window state persistence + +Test files co-located: `server-manager.test.ts`, `runner-manager.test.ts`, etc. + +--- + +## Future Considerations (Not in v1) + +- Windows and Linux support +- Bundled Redis (embed redis-server binary) +- Auto-updates via `electron-updater` +- Code signing and notarization for macOS distribution +- `.dmg` installer and Homebrew cask +- Global hotkeys (toggle visibility, new session) +- Deep links (`pizzapi://` protocol handler) +- Custom titlebar with traffic-light integration From c521bb7080db071e48ba1ef04e6a45192d2aa3fe Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:25:37 -0400 Subject: [PATCH 02/20] docs: add Electron desktop client implementation plan --- ...2026-04-01-electron-desktop-client-plan.md | 1261 +++++++++++++++++ 1 file changed, 1261 insertions(+) create mode 100644 docs/specs/2026-04-01-electron-desktop-client-plan.md diff --git a/docs/specs/2026-04-01-electron-desktop-client-plan.md b/docs/specs/2026-04-01-electron-desktop-client-plan.md new file mode 100644 index 000000000..c3899f739 --- /dev/null +++ b/docs/specs/2026-04-01-electron-desktop-client-plan.md @@ -0,0 +1,1261 @@ +# Electron Desktop Client — Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Create a native macOS Electron desktop app that embeds the PizzaPi relay server, runner daemon, and web UI into a self-contained application with system tray, native notifications, and auto-launch. + +**Architecture:** New `packages/desktop` workspace. Electron main process spawns the relay server and runner daemon as child processes. The renderer loads the existing `@pizzapi/ui` in a BrowserWindow — zero UI duplication. Native features (tray, notifications, auto-launch) live in the main process. + +**Tech Stack:** Electron 35+, electron-builder, TypeScript, `child_process` for server/runner lifecycle. + +--- + +## File Structure + +``` +packages/desktop/ +├── package.json ← workspace package, electron + electron-builder deps +├── electron-builder.yml ← electron-builder config (macOS arm64) +├── tsconfig.json ← extends root tsconfig.base.json +├── assets/ +│ ├── icon.png ← app icon (1024x1024) +│ ├── tray-default.png ← tray icon default (22x22 @2x template) +│ ├── tray-warning.png ← tray icon warning state +│ └── tray-error.png ← tray icon error state +├── src/ +│ ├── main/ +│ │ ├── index.ts ← app entry: ready, quit, window creation +│ │ ├── server-manager.ts ← spawn/stop/health-check relay server +│ │ ├── runner-manager.ts ← spawn/stop runner daemon +│ │ ├── tray.ts ← system tray icon + context menu +│ │ ├── notifications.ts ← native OS notification dispatch +│ │ ├── auto-launch.ts ← login item settings +│ │ ├── ipc.ts ← IPC channel handlers +│ │ ├── config.ts ← paths, ports, constants +│ │ └── logger.ts ← electron-log setup +│ └── preload/ +│ └── index.ts ← contextBridge API +└── tests/ + ├── server-manager.test.ts ← server lifecycle tests + └── runner-manager.test.ts ← runner lifecycle tests +``` + +--- + +### Task 1: Scaffold the `packages/desktop` workspace + +**Files:** +- Create: `packages/desktop/package.json` +- Create: `packages/desktop/tsconfig.json` +- Create: `packages/desktop/electron-builder.yml` +- Modify: root `package.json` (add workspace + scripts) + +- [ ] **Step 1: Create `packages/desktop/package.json`** + +```json +{ + "name": "@pizzapi/desktop", + "version": "0.1.0", + "private": true, + "type": "module", + "main": "dist/main/index.js", + "scripts": { + "dev": "concurrently \"bun run dev:electron\" \"bun run --cwd ../ui dev\" \"bun run --cwd ../server dev\" --kill-others-on-exit", + "dev:electron": "electron --inspect . --dev", + "build": "tsc --build", + "package": "electron-builder --mac", + "start": "electron ." + }, + "dependencies": { + "@pizzapi/protocol": "workspace:*", + "electron-log": "^5.3.0" + }, + "devDependencies": { + "electron": "^35.0.0", + "electron-builder": "^26.0.0", + "concurrently": "^9.2.1", + "typescript": "^5.7.0" + } +} +``` + +- [ ] **Step 2: Create `packages/desktop/tsconfig.json`** + +```json +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "outDir": "dist", + "rootDir": "src", + "module": "ESNext", + "moduleResolution": "bundler", + "target": "ES2022", + "declaration": true, + "sourceMap": true + }, + "include": ["src"], + "references": [ + { "path": "../protocol" } + ] +} +``` + +- [ ] **Step 3: Create `packages/desktop/electron-builder.yml`** + +```yaml +appId: com.pizzapi.desktop +productName: PizzaPi +copyright: Copyright © 2026 PizzaPi + +directories: + output: release + +mac: + category: public.app-category.developer-tools + target: + - target: dir + arch: + - arm64 + icon: assets/icon.png + +files: + - dist/**/* + - assets/**/* + - package.json + # Bundle the built UI assets + - from: ../ui/dist + to: ui-dist + filter: + - "**/*" + # Bundle the built server + - from: ../server/dist + to: server-dist + filter: + - "**/*" + # Bundle the built CLI (runner) + - from: ../cli/dist + to: cli-dist + filter: + - "**/*" + +extraMetadata: + main: dist/main/index.js +``` + +- [ ] **Step 4: Add workspace and scripts to root `package.json`** + +Add `"packages/desktop"` to the `workspaces` array. Add these scripts: + +```json +{ + "dev:desktop": "cd packages/desktop && bun run dev", + "build:desktop": "bun run build:ui && bun run build:server && bun run build:cli && cd packages/desktop && bun run build", + "package:desktop": "bun run build:desktop && cd packages/desktop && bun run package" +} +``` + +- [ ] **Step 5: Run `bun install` to link the new workspace** + +```bash +bun install +``` + +Expected: installs electron and electron-builder, links workspace deps. + +- [ ] **Step 6: Commit** + +```bash +git add packages/desktop/package.json packages/desktop/tsconfig.json packages/desktop/electron-builder.yml package.json bun.lock +git commit -m "feat(desktop): scaffold Electron workspace" +``` + +--- + +### Task 2: Config and logger modules + +**Files:** +- Create: `packages/desktop/src/main/config.ts` +- Create: `packages/desktop/src/main/logger.ts` + +- [ ] **Step 1: Create `packages/desktop/src/main/config.ts`** + +```typescript +import { app } from "electron"; +import { join } from "node:path"; + +/** Whether we're running in dev mode (passed via --dev flag). */ +export const isDev = process.argv.includes("--dev"); + +/** Default port for the relay server. */ +export const DEFAULT_SERVER_PORT = 3001; + +/** Vite dev server URL (used in dev mode only). */ +export const VITE_DEV_URL = "http://localhost:5173"; + +/** Path to the bundled UI dist assets (production). */ +export function getUIDistPath(): string { + if (isDev) { + return join(__dirname, "..", "..", "..", "ui", "dist"); + } + // In packaged app, electron-builder places them at ui-dist/ + return join(process.resourcesPath, "app", "ui-dist"); +} + +/** Path to the bundled server entry (production). */ +export function getServerEntryPath(): string { + if (isDev) { + return join(__dirname, "..", "..", "..", "server", "src", "index.ts"); + } + return join(process.resourcesPath, "app", "server-dist", "index.js"); +} + +/** Path to the bundled CLI entry for runner (production). */ +export function getRunnerEntryPath(): string { + if (isDev) { + return join(__dirname, "..", "..", "..", "cli", "src", "index.ts"); + } + return join(process.resourcesPath, "app", "cli-dist", "index.js"); +} + +/** App data directory. */ +export function getAppDataPath(): string { + return app.getPath("userData"); +} + +/** Logs directory. */ +export function getLogsPath(): string { + return app.getPath("logs"); +} + +/** Max restart attempts for child processes before showing error. */ +export const MAX_RESTART_ATTEMPTS = 3; + +/** Health check polling interval in ms. */ +export const HEALTH_CHECK_INTERVAL = 500; + +/** Health check timeout in ms. */ +export const HEALTH_CHECK_TIMEOUT = 30_000; +``` + +- [ ] **Step 2: Create `packages/desktop/src/main/logger.ts`** + +```typescript +import log from "electron-log/main"; + +log.initialize(); +log.transports.file.level = "info"; +log.transports.console.level = "debug"; + +export default log; +``` + +- [ ] **Step 3: Commit** + +```bash +git add packages/desktop/src/main/config.ts packages/desktop/src/main/logger.ts +git commit -m "feat(desktop): add config and logger modules" +``` + +--- + +### Task 3: Server manager — spawn, health-check, stop + +**Files:** +- Create: `packages/desktop/src/main/server-manager.ts` +- Create: `packages/desktop/tests/server-manager.test.ts` + +- [ ] **Step 1: Write the failing test** + +```typescript +// packages/desktop/tests/server-manager.test.ts +import { describe, test, expect, mock, beforeEach } from "bun:test"; + +// We test the pure logic by mocking child_process and fetch +const mockSpawn = mock(() => ({ + pid: 1234, + on: mock(() => {}), + kill: mock(() => true), + stdout: { on: mock(() => {}) }, + stderr: { on: mock(() => {}) }, +})); + +mock.module("node:child_process", () => ({ + spawn: mockSpawn, +})); + +describe("ServerManager", () => { + test("start() spawns a child process with the correct entry path", async () => { + const { ServerManager } = await import("../src/main/server-manager.js"); + const mgr = new ServerManager({ port: 3001, isDev: true }); + + // Mock fetch for health check + const originalFetch = globalThis.fetch; + globalThis.fetch = mock(() => Promise.resolve(new Response("ok", { status: 200 }))) as any; + + await mgr.start(); + + expect(mockSpawn).toHaveBeenCalled(); + expect(mgr.isRunning()).toBe(true); + + globalThis.fetch = originalFetch; + }); + + test("stop() sends SIGTERM to the child process", async () => { + const { ServerManager } = await import("../src/main/server-manager.js"); + const mgr = new ServerManager({ port: 3001, isDev: true }); + + const originalFetch = globalThis.fetch; + globalThis.fetch = mock(() => Promise.resolve(new Response("ok", { status: 200 }))) as any; + + await mgr.start(); + mgr.stop(); + + expect(mgr.isRunning()).toBe(false); + + globalThis.fetch = originalFetch; + }); + + test("getPort() returns the configured port", () => { + const { ServerManager } = await import("../src/main/server-manager.js"); + const mgr = new ServerManager({ port: 3042, isDev: true }); + expect(mgr.getPort()).toBe(3042); + }); +}); +``` + +- [ ] **Step 2: Run test to verify it fails** + +```bash +cd packages/desktop && bun test tests/server-manager.test.ts +``` + +Expected: FAIL — module `../src/main/server-manager.js` not found. + +- [ ] **Step 3: Implement `server-manager.ts`** + +```typescript +// packages/desktop/src/main/server-manager.ts +import { spawn, type ChildProcess } from "node:child_process"; +import { + getServerEntryPath, + HEALTH_CHECK_INTERVAL, + HEALTH_CHECK_TIMEOUT, + MAX_RESTART_ATTEMPTS, +} from "./config.js"; +import log from "./logger.js"; + +export interface ServerManagerOptions { + port: number; + isDev: boolean; +} + +export class ServerManager { + private child: ChildProcess | null = null; + private port: number; + private isDev: boolean; + private restartCount = 0; + private stopping = false; + + constructor(opts: ServerManagerOptions) { + this.port = opts.port; + this.isDev = opts.isDev; + } + + /** Spawn the relay server and wait for it to become healthy. */ + async start(): Promise { + this.stopping = false; + const entry = getServerEntryPath(); + log.info(`Starting relay server on port ${this.port}...`); + + const env = { + ...process.env, + PORT: String(this.port), + NODE_ENV: this.isDev ? "development" : "production", + }; + + this.child = spawn("bun", ["run", entry], { + env, + stdio: ["ignore", "pipe", "pipe"], + }); + + this.child.stdout?.on("data", (data: Buffer) => { + log.info(`[server] ${data.toString().trim()}`); + }); + + this.child.stderr?.on("data", (data: Buffer) => { + log.warn(`[server] ${data.toString().trim()}`); + }); + + this.child.on("exit", (code, signal) => { + log.info(`Server exited: code=${code} signal=${signal}`); + this.child = null; + if (!this.stopping && this.restartCount < MAX_RESTART_ATTEMPTS) { + this.restartCount++; + log.warn(`Restarting server (attempt ${this.restartCount}/${MAX_RESTART_ATTEMPTS})...`); + this.start().catch((err) => log.error("Server restart failed:", err)); + } + }); + + await this.waitForHealthy(); + this.restartCount = 0; + log.info(`Relay server healthy on port ${this.port}`); + } + + /** Poll /health until 200 or timeout. */ + private async waitForHealthy(): Promise { + const deadline = Date.now() + HEALTH_CHECK_TIMEOUT; + while (Date.now() < deadline) { + try { + const res = await fetch(`http://localhost:${this.port}/health`); + if (res.ok) return; + } catch { + // Server not ready yet + } + await new Promise((r) => setTimeout(r, HEALTH_CHECK_INTERVAL)); + } + throw new Error(`Server failed to become healthy within ${HEALTH_CHECK_TIMEOUT}ms`); + } + + /** Gracefully stop the server. */ + stop(): void { + this.stopping = true; + if (this.child) { + log.info("Stopping relay server..."); + this.child.kill("SIGTERM"); + this.child = null; + } + } + + /** Force-kill if still running. */ + forceKill(): void { + this.stopping = true; + if (this.child) { + this.child.kill("SIGKILL"); + this.child = null; + } + } + + isRunning(): boolean { + return this.child !== null; + } + + getPort(): number { + return this.port; + } +} +``` + +- [ ] **Step 4: Run test to verify it passes** + +```bash +cd packages/desktop && bun test tests/server-manager.test.ts +``` + +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add packages/desktop/src/main/server-manager.ts packages/desktop/tests/server-manager.test.ts +git commit -m "feat(desktop): add server manager with health check and auto-restart" +``` + +--- + +### Task 4: Runner manager — spawn, stop + +**Files:** +- Create: `packages/desktop/src/main/runner-manager.ts` +- Create: `packages/desktop/tests/runner-manager.test.ts` + +- [ ] **Step 1: Write the failing test** + +```typescript +// packages/desktop/tests/runner-manager.test.ts +import { describe, test, expect, mock } from "bun:test"; + +const mockSpawn = mock(() => ({ + pid: 5678, + on: mock(() => {}), + kill: mock(() => true), + stdout: { on: mock(() => {}) }, + stderr: { on: mock(() => {}) }, +})); + +mock.module("node:child_process", () => ({ + spawn: mockSpawn, +})); + +describe("RunnerManager", () => { + test("start() spawns the runner daemon pointing at the local server", async () => { + const { RunnerManager } = await import("../src/main/runner-manager.js"); + const mgr = new RunnerManager({ serverPort: 3001, isDev: true }); + + mgr.start(); + + expect(mockSpawn).toHaveBeenCalled(); + expect(mgr.isRunning()).toBe(true); + }); + + test("stop() sends SIGTERM to runner", () => { + const { RunnerManager } = await import("../src/main/runner-manager.js"); + const mgr = new RunnerManager({ serverPort: 3001, isDev: true }); + + mgr.start(); + mgr.stop(); + + expect(mgr.isRunning()).toBe(false); + }); +}); +``` + +- [ ] **Step 2: Run test to verify it fails** + +```bash +cd packages/desktop && bun test tests/runner-manager.test.ts +``` + +Expected: FAIL — module not found. + +- [ ] **Step 3: Implement `runner-manager.ts`** + +```typescript +// packages/desktop/src/main/runner-manager.ts +import { spawn, type ChildProcess } from "node:child_process"; +import { getRunnerEntryPath, MAX_RESTART_ATTEMPTS } from "./config.js"; +import log from "./logger.js"; + +export interface RunnerManagerOptions { + serverPort: number; + isDev: boolean; +} + +export class RunnerManager { + private child: ChildProcess | null = null; + private serverPort: number; + private isDev: boolean; + private restartCount = 0; + private stopping = false; + + constructor(opts: RunnerManagerOptions) { + this.serverPort = opts.serverPort; + this.isDev = opts.isDev; + } + + /** Spawn the runner daemon. */ + start(): void { + this.stopping = false; + const entry = getRunnerEntryPath(); + log.info("Starting runner daemon..."); + + const env = { + ...process.env, + PIZZAPI_SERVER_URL: `http://localhost:${this.serverPort}`, + }; + + this.child = spawn("bun", ["run", entry, "runner"], { + env, + stdio: ["ignore", "pipe", "pipe"], + }); + + this.child.stdout?.on("data", (data: Buffer) => { + log.info(`[runner] ${data.toString().trim()}`); + }); + + this.child.stderr?.on("data", (data: Buffer) => { + log.warn(`[runner] ${data.toString().trim()}`); + }); + + this.child.on("exit", (code, signal) => { + log.info(`Runner exited: code=${code} signal=${signal}`); + this.child = null; + if (!this.stopping && this.restartCount < MAX_RESTART_ATTEMPTS) { + this.restartCount++; + log.warn(`Restarting runner (attempt ${this.restartCount}/${MAX_RESTART_ATTEMPTS})...`); + this.start(); + } + }); + } + + /** Gracefully stop the runner. */ + stop(): void { + this.stopping = true; + if (this.child) { + log.info("Stopping runner daemon..."); + this.child.kill("SIGTERM"); + this.child = null; + } + } + + /** Force-kill if still running. */ + forceKill(): void { + this.stopping = true; + if (this.child) { + this.child.kill("SIGKILL"); + this.child = null; + } + } + + isRunning(): boolean { + return this.child !== null; + } +} +``` + +- [ ] **Step 4: Run test to verify it passes** + +```bash +cd packages/desktop && bun test tests/runner-manager.test.ts +``` + +Expected: PASS + +- [ ] **Step 5: Commit** + +```bash +git add packages/desktop/src/main/runner-manager.ts packages/desktop/tests/runner-manager.test.ts +git commit -m "feat(desktop): add runner manager with auto-restart" +``` + +--- + +### Task 5: System tray + +**Files:** +- Create: `packages/desktop/src/main/tray.ts` +- Create: `packages/desktop/assets/tray-default.png` (placeholder) +- Create: `packages/desktop/assets/tray-warning.png` (placeholder) +- Create: `packages/desktop/assets/tray-error.png` (placeholder) + +- [ ] **Step 1: Create placeholder tray icon assets** + +Create 44x44 PNG images (22pt @2x macOS template images). For now, use simple colored circles. The filenames must end in `Template.png` for macOS to treat them as template images (auto-adapts to dark/light menu bar). + +```bash +# Create assets directory +mkdir -p packages/desktop/assets +``` + +Generate minimal 44x44 placeholder PNGs (or copy from existing PizzaPi assets): + +```bash +# Use the existing pizza.svg as a base, or create placeholders +cp packages/ui/public/pwa-64x64.png packages/desktop/assets/tray-default.png +cp packages/ui/public/pwa-64x64.png packages/desktop/assets/tray-warning.png +cp packages/ui/public/pwa-64x64.png packages/desktop/assets/tray-error.png +cp packages/ui/public/pwa-512x512.png packages/desktop/assets/icon.png +``` + +- [ ] **Step 2: Implement `tray.ts`** + +```typescript +// packages/desktop/src/main/tray.ts +import { Tray, Menu, nativeImage, type BrowserWindow } from "electron"; +import { join } from "node:path"; +import log from "./logger.js"; + +export type ServiceHealth = "healthy" | "degraded" | "error"; + +export interface TrayStatus { + server: "starting" | "running" | "error" | "stopped"; + runner: "starting" | "running" | "error" | "stopped"; + redis: "connected" | "disconnected"; +} + +export class AppTray { + private tray: Tray; + private window: BrowserWindow; + private status: TrayStatus = { + server: "stopped", + runner: "stopped", + redis: "disconnected", + }; + + constructor(window: BrowserWindow) { + this.window = window; + + const iconPath = join(__dirname, "..", "..", "assets", "tray-default.png"); + const icon = nativeImage.createFromPath(iconPath).resize({ width: 22, height: 22 }); + icon.setTemplateImage(true); + + this.tray = new Tray(icon); + this.tray.setToolTip("PizzaPi"); + + this.tray.on("click", () => { + if (this.window.isVisible()) { + this.window.hide(); + } else { + this.window.show(); + this.window.focus(); + } + }); + + this.rebuildMenu(); + } + + updateStatus(status: Partial): void { + Object.assign(this.status, status); + this.updateIcon(); + this.rebuildMenu(); + } + + private getOverallHealth(): ServiceHealth { + const { server, runner, redis } = this.status; + if (server === "error" || redis === "disconnected") return "error"; + if (server === "starting" || runner === "starting") return "degraded"; + if (server === "running" && runner === "running" && redis === "connected") return "healthy"; + return "degraded"; + } + + private updateIcon(): void { + const health = this.getOverallHealth(); + const iconName = + health === "error" ? "tray-error.png" : + health === "degraded" ? "tray-warning.png" : + "tray-default.png"; + + const iconPath = join(__dirname, "..", "..", "assets", iconName); + const icon = nativeImage.createFromPath(iconPath).resize({ width: 22, height: 22 }); + icon.setTemplateImage(true); + this.tray.setImage(icon); + } + + private statusIcon(val: string): string { + if (val === "running" || val === "connected") return "✓"; + if (val === "starting") return "…"; + return "✕"; + } + + private rebuildMenu(): void { + const menu = Menu.buildFromTemplate([ + { + label: this.window.isVisible() ? "Hide Window" : "Show Window", + click: () => { + if (this.window.isVisible()) { + this.window.hide(); + } else { + this.window.show(); + this.window.focus(); + } + }, + }, + { type: "separator" }, + { + label: `Server: localhost ${this.statusIcon(this.status.server)}`, + enabled: false, + }, + { + label: `Runner: ${this.status.runner} ${this.statusIcon(this.status.runner)}`, + enabled: false, + }, + { + label: `Redis: ${this.status.redis} ${this.statusIcon(this.status.redis)}`, + enabled: false, + }, + { type: "separator" }, + { + label: "Quit PizzaPi", + role: "quit", + }, + ]); + + this.tray.setContextMenu(menu); + } + + destroy(): void { + this.tray.destroy(); + } +} +``` + +- [ ] **Step 3: Commit** + +```bash +git add packages/desktop/src/main/tray.ts packages/desktop/assets/ +git commit -m "feat(desktop): add system tray with health status" +``` + +--- + +### Task 6: Native notifications + +**Files:** +- Create: `packages/desktop/src/main/notifications.ts` + +- [ ] **Step 1: Implement `notifications.ts`** + +```typescript +// packages/desktop/src/main/notifications.ts +import { Notification, type BrowserWindow } from "electron"; +import log from "./logger.js"; + +export interface NotificationOptions { + title: string; + body: string; + /** If set, clicking the notification focuses the window. */ + window?: BrowserWindow; +} + +export function showNotification(opts: NotificationOptions): void { + if (!Notification.isSupported()) { + log.warn("Notifications not supported on this platform"); + return; + } + + const notification = new Notification({ + title: opts.title, + body: opts.body, + silent: false, + }); + + if (opts.window) { + notification.on("click", () => { + opts.window!.show(); + opts.window!.focus(); + }); + } + + notification.show(); +} + +export function notifySessionComplete(window: BrowserWindow, sessionName: string, duration: string): void { + showNotification({ + title: "Session Complete", + body: `Agent finished "${sessionName}" in ${duration}`, + window, + }); +} + +export function notifyAgentNeedsInput(window: BrowserWindow, sessionName: string): void { + showNotification({ + title: "Agent Needs Input", + body: `Session "${sessionName}" is waiting for your response`, + window, + }); +} + +export function notifyServiceError(window: BrowserWindow, error: string): void { + showNotification({ + title: "Service Error", + body: error, + window, + }); +} +``` + +- [ ] **Step 2: Commit** + +```bash +git add packages/desktop/src/main/notifications.ts +git commit -m "feat(desktop): add native notification helpers" +``` + +--- + +### Task 7: Auto-launch + +**Files:** +- Create: `packages/desktop/src/main/auto-launch.ts` + +- [ ] **Step 1: Implement `auto-launch.ts`** + +```typescript +// packages/desktop/src/main/auto-launch.ts +import { app } from "electron"; +import log from "./logger.js"; + +export function getAutoLaunchEnabled(): boolean { + const settings = app.getLoginItemSettings(); + return settings.openAtLogin; +} + +export function setAutoLaunchEnabled(enabled: boolean): void { + log.info(`Setting auto-launch: ${enabled}`); + app.setLoginItemSettings({ + openAtLogin: enabled, + openAsHidden: true, // Start minimized to tray + }); +} +``` + +- [ ] **Step 2: Commit** + +```bash +git add packages/desktop/src/main/auto-launch.ts +git commit -m "feat(desktop): add auto-launch login item support" +``` + +--- + +### Task 8: IPC handlers and preload script + +**Files:** +- Create: `packages/desktop/src/main/ipc.ts` +- Create: `packages/desktop/src/preload/index.ts` + +- [ ] **Step 1: Implement `ipc.ts`** + +```typescript +// packages/desktop/src/main/ipc.ts +import { ipcMain, type BrowserWindow } from "electron"; +import { app } from "electron"; +import { getAutoLaunchEnabled, setAutoLaunchEnabled } from "./auto-launch.js"; +import type { TrayStatus } from "./tray.js"; +import log from "./logger.js"; + +/** + * Register all IPC handlers. Call once at app startup. + */ +export function registerIpcHandlers(): void { + ipcMain.handle("desktop:getVersion", () => app.getVersion()); + ipcMain.handle("desktop:getPlatform", () => process.platform); + ipcMain.handle("desktop:getAutoLaunch", () => getAutoLaunchEnabled()); + ipcMain.handle("desktop:setAutoLaunch", (_event, enabled: boolean) => { + setAutoLaunchEnabled(enabled); + }); + + log.info("IPC handlers registered"); +} + +/** + * Send service status update to all renderer windows. + */ +export function sendServiceStatus(window: BrowserWindow, status: TrayStatus): void { + window.webContents.send("desktop:serviceStatus", status); +} +``` + +- [ ] **Step 2: Implement `preload/index.ts`** + +```typescript +// packages/desktop/src/preload/index.ts +import { contextBridge, ipcRenderer } from "electron"; + +export interface DesktopAPI { + getVersion(): Promise; + getPlatform(): Promise; + getAutoLaunch(): Promise; + setAutoLaunch(enabled: boolean): Promise; + onServiceStatus(callback: (status: any) => void): () => void; +} + +const desktopAPI: DesktopAPI = { + getVersion: () => ipcRenderer.invoke("desktop:getVersion"), + getPlatform: () => ipcRenderer.invoke("desktop:getPlatform"), + getAutoLaunch: () => ipcRenderer.invoke("desktop:getAutoLaunch"), + setAutoLaunch: (enabled) => ipcRenderer.invoke("desktop:setAutoLaunch", enabled), + onServiceStatus: (callback) => { + const handler = (_event: any, status: any) => callback(status); + ipcRenderer.on("desktop:serviceStatus", handler); + // Return cleanup function + return () => ipcRenderer.removeListener("desktop:serviceStatus", handler); + }, +}; + +contextBridge.exposeInMainWorld("desktopAPI", desktopAPI); +``` + +- [ ] **Step 3: Commit** + +```bash +git add packages/desktop/src/main/ipc.ts packages/desktop/src/preload/index.ts +git commit -m "feat(desktop): add IPC handlers and preload bridge" +``` + +--- + +### Task 9: Main process entry — tie everything together + +**Files:** +- Create: `packages/desktop/src/main/index.ts` + +- [ ] **Step 1: Implement `index.ts`** + +```typescript +// packages/desktop/src/main/index.ts +import { app, BrowserWindow, dialog } from "electron"; +import { join } from "node:path"; +import { ServerManager } from "./server-manager.js"; +import { RunnerManager } from "./runner-manager.js"; +import { AppTray } from "./tray.js"; +import { registerIpcHandlers, sendServiceStatus } from "./ipc.js"; +import { notifyServiceError } from "./notifications.js"; +import { isDev, DEFAULT_SERVER_PORT, VITE_DEV_URL, getUIDistPath } from "./config.js"; +import log from "./logger.js"; + +let mainWindow: BrowserWindow | null = null; +let tray: AppTray | null = null; +let serverManager: ServerManager | null = null; +let runnerManager: RunnerManager | null = null; + +function createWindow(): BrowserWindow { + const win = new BrowserWindow({ + width: 1280, + height: 800, + minWidth: 800, + minHeight: 600, + title: "PizzaPi", + titleBarStyle: "hiddenInset", + trafficLightPosition: { x: 16, y: 16 }, + webPreferences: { + preload: join(__dirname, "..", "preload", "index.js"), + contextIsolation: true, + nodeIntegration: false, + }, + }); + + // Hide instead of close (app lives in tray) + win.on("close", (event) => { + if (!app.isQuitting) { + event.preventDefault(); + win.hide(); + } + }); + + return win; +} + +async function checkRedis(): Promise { + try { + // Quick TCP connect check to default Redis port + const net = await import("node:net"); + return new Promise((resolve) => { + const socket = net.createConnection({ port: 6379, host: "127.0.0.1" }); + socket.on("connect", () => { + socket.destroy(); + resolve(true); + }); + socket.on("error", () => { + resolve(false); + }); + socket.setTimeout(2000, () => { + socket.destroy(); + resolve(false); + }); + }); + } catch { + return false; + } +} + +async function startServices(): Promise { + if (!mainWindow) return; + + // Check Redis first + tray?.updateStatus({ redis: "disconnected", server: "starting" }); + + const redisAvailable = await checkRedis(); + if (!redisAvailable) { + tray?.updateStatus({ redis: "disconnected" }); + notifyServiceError(mainWindow, "Redis is not available. Please start Redis and relaunch."); + dialog.showErrorBox( + "Redis Required", + "PizzaPi requires Redis to be running.\n\nInstall with: brew install redis\nStart with: redis-server\n\nPlease start Redis and relaunch PizzaPi." + ); + return; + } + + tray?.updateStatus({ redis: "connected" }); + + // Start relay server + serverManager = new ServerManager({ port: DEFAULT_SERVER_PORT, isDev }); + tray?.updateStatus({ server: "starting" }); + + try { + await serverManager.start(); + tray?.updateStatus({ server: "running" }); + if (mainWindow) { + sendServiceStatus(mainWindow, { + server: "running", + runner: "starting", + redis: "connected", + }); + } + } catch (err) { + log.error("Failed to start server:", err); + tray?.updateStatus({ server: "error" }); + notifyServiceError(mainWindow!, `Server failed to start: ${err}`); + return; + } + + // Start runner daemon + runnerManager = new RunnerManager({ serverPort: DEFAULT_SERVER_PORT, isDev }); + tray?.updateStatus({ runner: "starting" }); + runnerManager.start(); + tray?.updateStatus({ runner: "running" }); + + if (mainWindow) { + sendServiceStatus(mainWindow, { + server: "running", + runner: "running", + redis: "connected", + }); + } + + // Load the UI + if (isDev) { + await mainWindow!.loadURL(VITE_DEV_URL); + mainWindow!.webContents.openDevTools(); + } else { + const uiPath = getUIDistPath(); + await mainWindow!.loadFile(join(uiPath, "index.html")); + } +} + +async function shutdown(): Promise { + log.info("Shutting down..."); + + if (runnerManager) { + runnerManager.stop(); + // Wait briefly for graceful shutdown + await new Promise((r) => setTimeout(r, 2000)); + runnerManager.forceKill(); + } + + if (serverManager) { + serverManager.stop(); + await new Promise((r) => setTimeout(r, 2000)); + serverManager.forceKill(); + } + + tray?.destroy(); +} + +// ── App lifecycle ───────────────────────────────────────────────────────────── + +// Extend app type to track quitting state +declare module "electron" { + interface App { + isQuitting: boolean; + } +} +app.isQuitting = false; + +app.on("before-quit", () => { + app.isQuitting = true; +}); + +app.whenReady().then(async () => { + log.info(`PizzaPi Desktop starting (dev=${isDev})...`); + + registerIpcHandlers(); + + mainWindow = createWindow(); + tray = new AppTray(mainWindow); + + await startServices(); +}); + +app.on("will-quit", async (event) => { + event.preventDefault(); + await shutdown(); + app.exit(0); +}); + +app.on("window-all-closed", () => { + // On macOS, don't quit when all windows are closed (app lives in tray) + if (process.platform !== "darwin") { + app.quit(); + } +}); + +app.on("activate", () => { + // On macOS, re-show the window when dock icon is clicked + if (mainWindow) { + mainWindow.show(); + mainWindow.focus(); + } +}); +``` + +- [ ] **Step 2: Verify TypeScript compiles** + +```bash +cd packages/desktop && npx tsc --noEmit +``` + +Expected: no errors (or only errors related to electron types which we'll fix with the build). + +- [ ] **Step 3: Commit** + +```bash +git add packages/desktop/src/main/index.ts +git commit -m "feat(desktop): add main process entry with full lifecycle orchestration" +``` + +--- + +### Task 10: Dev smoke test — launch the Electron app + +- [ ] **Step 1: Build the desktop TypeScript** + +```bash +cd packages/desktop && bun run build +``` + +Expected: compiles to `dist/`. + +- [ ] **Step 2: Start Redis (if not running)** + +```bash +redis-server --daemonize yes +``` + +- [ ] **Step 3: Launch in dev mode** + +```bash +cd packages/desktop && bun run dev +``` + +Expected: Vite dev server starts, relay server starts, Electron window opens showing the PizzaPi UI. System tray icon appears with green status. + +- [ ] **Step 4: Verify tray menu** + +Click the tray icon → context menu should show server/runner/Redis status as connected. + +- [ ] **Step 5: Verify window hide/show** + +Close the window → app should stay in tray. Click tray icon → window reappears. Cmd+Q → app quits, all child processes cleaned up. + +- [ ] **Step 6: Commit any fixes from smoke test** + +```bash +git add -A +git commit -m "fix(desktop): smoke test fixes" +``` + +--- + +### Task 11: Run all tests and typecheck + +- [ ] **Step 1: Run desktop tests** + +```bash +cd packages/desktop && bun test +``` + +Expected: all tests pass. + +- [ ] **Step 2: Run full repo typecheck** + +```bash +bun run typecheck +``` + +Expected: no new type errors. + +- [ ] **Step 3: Run full repo tests** + +```bash +bun run test +``` + +Expected: all existing tests still pass. + +- [ ] **Step 4: Final commit and push** + +```bash +git add -A +git commit -m "feat(desktop): Electron desktop client v1" +git push -u origin feat/electron-desktop-client +``` From c7723ef6f07f4d74d9fc3e3420e2765a48f53b28 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:28:22 -0400 Subject: [PATCH 03/20] feat(desktop): scaffold Electron workspace --- bun.lock | 522 +++++++++++++++++++++++++- package.json | 6 +- packages/desktop/electron-builder.yml | 37 ++ packages/desktop/package.json | 24 ++ packages/desktop/tsconfig.json | 16 + 5 files changed, 598 insertions(+), 7 deletions(-) create mode 100644 packages/desktop/electron-builder.yml create mode 100644 packages/desktop/package.json create mode 100644 packages/desktop/tsconfig.json diff --git a/bun.lock b/bun.lock index 45574e7c0..758caeed0 100644 --- a/bun.lock +++ b/bun.lock @@ -20,7 +20,7 @@ }, "packages/cli": { "name": "@pizzapi/cli", - "version": "0.5.0-dev.2", + "version": "0.5.0-dev.4", "bin": { "pizza": "src/index.ts", "pizzapi": "src/index.ts", @@ -40,6 +40,20 @@ "typescript": "^5.7.0", }, }, + "packages/desktop": { + "name": "@pizzapi/desktop", + "version": "0.1.0", + "dependencies": { + "@pizzapi/protocol": "workspace:*", + "electron-log": "^5.3.0", + }, + "devDependencies": { + "concurrently": "^9.2.1", + "electron": "^35.0.0", + "electron-builder": "^26.0.0", + "typescript": "^5.7.0", + }, + }, "packages/docs": { "name": "@pizzapi/docs", "version": "0.0.1", @@ -174,6 +188,8 @@ "@mariozechner/pi-coding-agent@0.63.1": "patches/@mariozechner%2Fpi-coding-agent@0.63.1.patch", }, "packages": { + "7zip-bin": ["7zip-bin@5.2.0", "", {}, "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A=="], + "@ai-sdk/gateway": ["@ai-sdk/gateway@3.0.53", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.15", "@vercel/oidc": "3.1.0" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-QT3FEoNARMRlk8JJVR7L98exiK9C8AGfrEJVbRxBT1yIXKs/N19o/+PsjTRVsARgDJNcy9JbJp1FspKucEat0Q=="], "@ai-sdk/provider": ["@ai-sdk/provider@3.0.8", "", { "dependencies": { "json-schema": "^0.4.0" } }, "sha512-oGMAgGoQdBXbZqNG0Ze56CHjDZ1IDYOwGYxYjO5KLSlz5HiNQ9udIXsPZ61VWaHGZ5XW/jyjmr6t2xz2jGVwbQ=="], @@ -530,10 +546,28 @@ "@ctrl/tinycolor": ["@ctrl/tinycolor@4.2.0", "", {}, "sha512-kzyuwOAQnXJNLS9PSyrk0CWk35nWJW/zl/6KvnTBMFK65gm7U1/Z5BqjxeapjZCIhQcM/DsrEmcbRwDyXyXK4A=="], + "@develar/schema-utils": ["@develar/schema-utils@2.6.5", "", { "dependencies": { "ajv": "^6.12.0", "ajv-keywords": "^3.4.1" } }, "sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig=="], + "@dotenvx/dotenvx": ["@dotenvx/dotenvx@1.52.0", "", { "dependencies": { "commander": "^11.1.0", "dotenv": "^17.2.1", "eciesjs": "^0.4.10", "execa": "^5.1.1", "fdir": "^6.2.0", "ignore": "^5.3.0", "object-treeify": "1.1.33", "picomatch": "^4.0.2", "which": "^4.0.0" }, "bin": { "dotenvx": "src/cli/dotenvx.js" } }, "sha512-CaQcc8JvtzQhUSm9877b6V4Tb7HCotkcyud9X2YwdqtQKwgljkMRwU96fVYKnzN3V0Hj74oP7Es+vZ0mS+Aa1w=="], "@ecies/ciphers": ["@ecies/ciphers@0.2.5", "", { "peerDependencies": { "@noble/ciphers": "^1.0.0" } }, "sha512-GalEZH4JgOMHYYcYmVqnFirFsjZHeoGMDt9IxEnM9F7GRUUyUksJ7Ou53L83WHJq3RWKD3AcBpo0iQh0oMpf8A=="], + "@electron/asar": ["@electron/asar@3.4.1", "", { "dependencies": { "commander": "^5.0.0", "glob": "^7.1.6", "minimatch": "^3.0.4" }, "bin": { "asar": "bin/asar.js" } }, "sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA=="], + + "@electron/fuses": ["@electron/fuses@1.8.0", "", { "dependencies": { "chalk": "^4.1.1", "fs-extra": "^9.0.1", "minimist": "^1.2.5" }, "bin": { "electron-fuses": "dist/bin.js" } }, "sha512-zx0EIq78WlY/lBb1uXlziZmDZI4ubcCXIMJ4uGjXzZW0nS19TjSPeXPAjzzTmKQlJUZm0SbmZhPKP7tuQ1SsEw=="], + + "@electron/get": ["@electron/get@2.0.3", "", { "dependencies": { "debug": "^4.1.1", "env-paths": "^2.2.0", "fs-extra": "^8.1.0", "got": "^11.8.5", "progress": "^2.0.3", "semver": "^6.2.0", "sumchecker": "^3.0.1" }, "optionalDependencies": { "global-agent": "^3.0.0" } }, "sha512-Qkzpg2s9GnVV2I2BjRksUi43U5e6+zaQMcjoJy0C+C5oxaKl+fmckGDQFtRpZpZV0NQekuZZ+tGz7EA9TVnQtQ=="], + + "@electron/notarize": ["@electron/notarize@2.5.0", "", { "dependencies": { "debug": "^4.1.1", "fs-extra": "^9.0.1", "promise-retry": "^2.0.1" } }, "sha512-jNT8nwH1f9X5GEITXaQ8IF/KdskvIkOFfB2CvwumsveVidzpSc+mvhhTMdAGSYF3O+Nq49lJ7y+ssODRXu06+A=="], + + "@electron/osx-sign": ["@electron/osx-sign@1.3.3", "", { "dependencies": { "compare-version": "^0.1.2", "debug": "^4.3.4", "fs-extra": "^10.0.0", "isbinaryfile": "^4.0.8", "minimist": "^1.2.6", "plist": "^3.0.5" }, "bin": { "electron-osx-flat": "bin/electron-osx-flat.js", "electron-osx-sign": "bin/electron-osx-sign.js" } }, "sha512-KZ8mhXvWv2rIEgMbWZ4y33bDHyUKMXnx4M0sTyPNK/vcB81ImdeY9Ggdqy0SWbMDgmbqyQ+phgejh6V3R2QuSg=="], + + "@electron/rebuild": ["@electron/rebuild@4.0.3", "", { "dependencies": { "@malept/cross-spawn-promise": "^2.0.0", "debug": "^4.1.1", "detect-libc": "^2.0.1", "got": "^11.7.0", "graceful-fs": "^4.2.11", "node-abi": "^4.2.0", "node-api-version": "^0.2.1", "node-gyp": "^11.2.0", "ora": "^5.1.0", "read-binary-file-arch": "^1.0.6", "semver": "^7.3.5", "tar": "^7.5.6", "yargs": "^17.0.1" }, "bin": { "electron-rebuild": "lib/cli.js" } }, "sha512-u9vpTHRMkOYCs/1FLiSVAFZ7FbjsXK+bQuzviJZa+lG7BHZl1nz52/IcGvwa3sk80/fc3llutBkbCq10Vh8WQA=="], + + "@electron/universal": ["@electron/universal@2.0.3", "", { "dependencies": { "@electron/asar": "^3.3.1", "@malept/cross-spawn-promise": "^2.0.0", "debug": "^4.3.1", "dir-compare": "^4.2.0", "fs-extra": "^11.1.1", "minimatch": "^9.0.3", "plist": "^3.1.0" } }, "sha512-Wn9sPYIVFRFl5HmwMJkARCCf7rqK/EurkfQ/rJZ14mHP3iYTjZSIOSVonEAnhWeAXwtw7zOekGRlc6yTtZ0t+g=="], + + "@electron/windows-sign": ["@electron/windows-sign@1.2.2", "", { "dependencies": { "cross-dirname": "^0.1.0", "debug": "^4.3.4", "fs-extra": "^11.1.1", "minimist": "^1.2.8", "postject": "^1.0.0-alpha.6" }, "bin": { "electron-windows-sign": "bin/electron-windows-sign.js" } }, "sha512-dfZeox66AvdPtb2lD8OsIIQh12Tp0GNCRUDfBHIKGpbmopZto2/A8nSpYYLoedPIHpqkeblZ/k8OV0Gy7PYuyQ=="], + "@emnapi/runtime": ["@emnapi/runtime@1.8.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-mehfKSMWjjNol8659Z8KxEMrdSJDDot5SXMq00dM8BN4o+CLNXQ0xH2V7EchNHV4RmbZLmmPdEaXZc5H2FXmDg=="], "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.3", "", { "os": "aix", "cpu": "ppc64" }, "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg=="], @@ -688,6 +722,10 @@ "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="], + "@malept/cross-spawn-promise": ["@malept/cross-spawn-promise@2.0.0", "", { "dependencies": { "cross-spawn": "^7.0.1" } }, "sha512-1DpKU0Z5ThltBwjNySMC14g0CkbyhCaz9FkhxqNsZI6uAPJXFS8cMXlBKo26FJ8ZuW6S9GCMcR9IO5k2X5/9Fg=="], + + "@malept/flatpak-bundler": ["@malept/flatpak-bundler@0.4.0", "", { "dependencies": { "debug": "^4.1.1", "fs-extra": "^9.0.0", "lodash": "^4.17.15", "tmp-promise": "^3.0.2" } }, "sha512-9QOtNffcOF/c1seMCDnjckb3R9WHcG34tky+FHpNKKCW0wc/scYLwMtO+ptyGUfMW0/b/n4qRiALlaFHc9Oj7Q=="], + "@mariozechner/clipboard": ["@mariozechner/clipboard@0.3.2", "", { "optionalDependencies": { "@mariozechner/clipboard-darwin-arm64": "0.3.2", "@mariozechner/clipboard-darwin-universal": "0.3.2", "@mariozechner/clipboard-darwin-x64": "0.3.2", "@mariozechner/clipboard-linux-arm64-gnu": "0.3.2", "@mariozechner/clipboard-linux-arm64-musl": "0.3.2", "@mariozechner/clipboard-linux-riscv64-gnu": "0.3.2", "@mariozechner/clipboard-linux-x64-gnu": "0.3.2", "@mariozechner/clipboard-linux-x64-musl": "0.3.2", "@mariozechner/clipboard-win32-arm64-msvc": "0.3.2", "@mariozechner/clipboard-win32-x64-msvc": "0.3.2" } }, "sha512-IHQpksNjo7EAtGuHFU+tbWDp5LarH3HU/8WiB9O70ZEoBPHOg0/6afwSLK0QyNMMmx4Bpi/zl6+DcBXe95nWYA=="], "@mariozechner/clipboard-darwin-arm64": ["@mariozechner/clipboard-darwin-arm64@0.3.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-uBf6K7Je1ihsgvmWxA8UCGCeI+nbRVRXoarZdLjl6slz94Zs1tNKFZqx7aCI5O1i3e0B6ja82zZ06BWrl0MCVw=="], @@ -744,6 +782,10 @@ "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="], + "@npmcli/agent": ["@npmcli/agent@3.0.0", "", { "dependencies": { "agent-base": "^7.1.0", "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.1", "lru-cache": "^10.0.1", "socks-proxy-agent": "^8.0.3" } }, "sha512-S79NdEgDQd/NGCay6TCoVzXSj74skRZIKJcpJjC5lOq34SZzyI6MqtiiWoiVWoVrTcGjNeC4ipbh1VIHlpfF5Q=="], + + "@npmcli/fs": ["@npmcli/fs@4.0.0", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-/xGlezI6xfGO9NwuJlnwz/K14qD1kCSAGtacBHnGzeAIuJGazcp45KP5NuyARXoKb7cwulAGWVsbeSxdG/cb0Q=="], + "@open-draft/deferred-promise": ["@open-draft/deferred-promise@2.2.0", "", {}, "sha512-CecwLWx3rhxVQF6V4bAgPS5t+So2sTbPgAzafKkVizyi7tlwpcFpdFqq+wqF2OwNBmqFuu6tOyouTuxgpMfzmA=="], "@open-draft/logger": ["@open-draft/logger@0.3.0", "", { "dependencies": { "is-node-process": "^1.2.0", "outvariant": "^1.4.0" } }, "sha512-X2g45fzhxH238HKO4xbSr7+wBS8Fvw6ixhTDuvLd5mqh6bJJCFAPwU9mPDxbcrRtfxv4u5IHCEH77BmxvXmmxQ=="], @@ -770,6 +812,8 @@ "@pizzapi/cli": ["@pizzapi/cli@workspace:packages/cli"], + "@pizzapi/desktop": ["@pizzapi/desktop@workspace:packages/desktop"], + "@pizzapi/docs": ["@pizzapi/docs@workspace:packages/docs"], "@pizzapi/protocol": ["@pizzapi/protocol@workspace:packages/protocol"], @@ -1028,6 +1072,8 @@ "@sinclair/typebox": ["@sinclair/typebox@0.34.48", "", {}, "sha512-kKJTNuK3AQOrgjjotVxMrCn1sUJwM76wMszfq1kdU4uYVJjvEWuFQ6HgvLt4Xz3fSmZlTOxJ/Ie13KnIcWQXFA=="], + "@sindresorhus/is": ["@sindresorhus/is@4.6.0", "", {}, "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw=="], + "@sindresorhus/merge-streams": ["@sindresorhus/merge-streams@4.0.0", "", {}, "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ=="], "@smithy/abort-controller": ["@smithy/abort-controller@4.2.8", "", { "dependencies": { "@smithy/types": "^4.12.0", "tslib": "^2.6.2" } }, "sha512-peuVfkYHAmS5ybKxWcfraK7WBBP0J+rkfUcbHJJKQ4ir3UAUNQI+Y4Vt/PqSzGqgloJ5O1dk7+WzNL8wcCSXbw=="], @@ -1176,6 +1222,8 @@ "@swc/types": ["@swc/types@0.1.25", "", { "dependencies": { "@swc/counter": "^0.1.3" } }, "sha512-iAoY/qRhNH8a/hBvm3zKj9qQ4oc2+3w1unPJa2XvTK3XjeLXtzcCingVPw/9e5mn1+0yPqxcBGp9Jf0pkfMb1g=="], + "@szmarczak/http-timer": ["@szmarczak/http-timer@4.0.6", "", { "dependencies": { "defer-to-connect": "^2.0.0" } }, "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w=="], + "@tailwindcss/node": ["@tailwindcss/node@4.2.0", "", { "dependencies": { "@jridgewell/remapping": "^2.3.5", "enhanced-resolve": "^5.19.0", "jiti": "^2.6.1", "lightningcss": "1.31.1", "magic-string": "^0.30.21", "source-map-js": "^1.2.1", "tailwindcss": "4.2.0" } }, "sha512-Yv+fn/o2OmL5fh/Ir62VXItdShnUxfpkMA4Y7jdeC8O81WPB8Kf6TT6GSHvnqgSwDzlB5iT7kDpeXxLsUS0T6Q=="], "@tailwindcss/oxide": ["@tailwindcss/oxide@4.2.0", "", { "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.2.0", "@tailwindcss/oxide-darwin-arm64": "4.2.0", "@tailwindcss/oxide-darwin-x64": "4.2.0", "@tailwindcss/oxide-freebsd-x64": "4.2.0", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.2.0", "@tailwindcss/oxide-linux-arm64-gnu": "4.2.0", "@tailwindcss/oxide-linux-arm64-musl": "4.2.0", "@tailwindcss/oxide-linux-x64-gnu": "4.2.0", "@tailwindcss/oxide-linux-x64-musl": "4.2.0", "@tailwindcss/oxide-wasm32-wasi": "4.2.0", "@tailwindcss/oxide-win32-arm64-msvc": "4.2.0", "@tailwindcss/oxide-win32-x64-msvc": "4.2.0" } }, "sha512-AZqQzADaj742oqn2xjl5JbIOzZB/DGCYF/7bpvhA8KvjUj9HJkag6bBuwZvH1ps6dfgxNHyuJVlzSr2VpMgdTQ=="], @@ -1234,6 +1282,8 @@ "@types/bun": ["@types/bun@1.3.9", "", { "dependencies": { "bun-types": "1.3.9" } }, "sha512-KQ571yULOdWJiMH+RIWIOZ7B2RXQGpL1YQrBtLIV3FqDcCu6FsbFUBwhdKUlCKUpS3PJDsHlJ1QKlpxoVR+xtw=="], + "@types/cacheable-request": ["@types/cacheable-request@6.0.3", "", { "dependencies": { "@types/http-cache-semantics": "*", "@types/keyv": "^3.1.4", "@types/node": "*", "@types/responselike": "^1.0.0" } }, "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw=="], + "@types/cors": ["@types/cors@2.8.19", "", { "dependencies": { "@types/node": "*" } }, "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg=="], "@types/d3": ["@types/d3@7.4.3", "", { "dependencies": { "@types/d3-array": "*", "@types/d3-axis": "*", "@types/d3-brush": "*", "@types/d3-chord": "*", "@types/d3-color": "*", "@types/d3-contour": "*", "@types/d3-delaunay": "*", "@types/d3-dispatch": "*", "@types/d3-drag": "*", "@types/d3-dsv": "*", "@types/d3-ease": "*", "@types/d3-fetch": "*", "@types/d3-force": "*", "@types/d3-format": "*", "@types/d3-geo": "*", "@types/d3-hierarchy": "*", "@types/d3-interpolate": "*", "@types/d3-path": "*", "@types/d3-polygon": "*", "@types/d3-quadtree": "*", "@types/d3-random": "*", "@types/d3-scale": "*", "@types/d3-scale-chromatic": "*", "@types/d3-selection": "*", "@types/d3-shape": "*", "@types/d3-time": "*", "@types/d3-time-format": "*", "@types/d3-timer": "*", "@types/d3-transition": "*", "@types/d3-zoom": "*" } }, "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww=="], @@ -1304,14 +1354,20 @@ "@types/estree-jsx": ["@types/estree-jsx@1.0.5", "", { "dependencies": { "@types/estree": "*" } }, "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg=="], + "@types/fs-extra": ["@types/fs-extra@9.0.13", "", { "dependencies": { "@types/node": "*" } }, "sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA=="], + "@types/geojson": ["@types/geojson@7946.0.16", "", {}, "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg=="], "@types/hast": ["@types/hast@3.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ=="], + "@types/http-cache-semantics": ["@types/http-cache-semantics@4.2.0", "", {}, "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q=="], + "@types/js-yaml": ["@types/js-yaml@4.0.9", "", {}, "sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg=="], "@types/katex": ["@types/katex@0.16.8", "", {}, "sha512-trgaNyfU+Xh2Tc+ABIb44a5AYUpicB3uwirOioeOkNPPbmgRNtcWyDeeFRzjPZENO9Vq8gvVqfhaaXWLlevVwg=="], + "@types/keyv": ["@types/keyv@3.1.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg=="], + "@types/lodash": ["@types/lodash@4.17.24", "", {}, "sha512-gIW7lQLZbue7lRSWEFql49QJJWThrTFFeIMJdp3eH4tKoxm1OvEPg02rm4wCCSHS0cL3/Fizimb35b7k8atwsQ=="], "@types/lodash-es": ["@types/lodash-es@4.17.12", "", { "dependencies": { "@types/lodash": "*" } }, "sha512-0NgftHUcV4v34VhXm8QBSftKVXtbkBG3ViCjs6+eJ5a6y6Mi/jiFGPc1sC7QK+9BFhWrURE3EOggmWaSxL9OzQ=="], @@ -1326,10 +1382,12 @@ "@types/nlcst": ["@types/nlcst@2.0.3", "", { "dependencies": { "@types/unist": "*" } }, "sha512-vSYNSDe6Ix3q+6Z7ri9lyWqgGhJTmzRjZRqyq15N0Z/1/UnVsno9G/N40NBijoYx2seFDIl0+B2mgAb9mezUCA=="], - "@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + "@types/node": ["@types/node@22.19.15", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg=="], "@types/pg": ["@types/pg@8.16.0", "", { "dependencies": { "@types/node": "*", "pg-protocol": "*", "pg-types": "^2.2.0" } }, "sha512-RmhMd/wD+CF8Dfo+cVIy3RR5cl8CyfXQ0tGgW6XBL8L4LM/UTEbNXYRbLwU6w+CgrKBNbrQWt4FUtTfaU5jSYQ=="], + "@types/plist": ["@types/plist@3.0.5", "", { "dependencies": { "@types/node": "*", "xmlbuilder": ">=11.0.1" } }, "sha512-E6OCaRmAe4WDmWNsL/9RMqdkkzDCY1etutkflWk4c+AcjDU07Pcz1fQwTX0TQz+Pxqn9i4L1TU3UFpjnrcDgxA=="], + "@types/react": ["@types/react@19.2.14", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w=="], "@types/react-dom": ["@types/react-dom@19.2.3", "", { "peerDependencies": { "@types/react": "^19.2.0" } }, "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ=="], @@ -1338,6 +1396,8 @@ "@types/resolve": ["@types/resolve@1.20.2", "", {}, "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q=="], + "@types/responselike": ["@types/responselike@1.0.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw=="], + "@types/retry": ["@types/retry@0.12.0", "", {}, "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA=="], "@types/sax": ["@types/sax@1.2.7", "", { "dependencies": { "@types/node": "*" } }, "sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A=="], @@ -1352,6 +1412,8 @@ "@types/validate-npm-package-name": ["@types/validate-npm-package-name@4.0.2", "", {}, "sha512-lrpDziQipxCEeK5kWxvljWYhUvOiB2A9izZd9B2AFarYAkqZshb4lPbRs7zKEic6eGtH8V/2qJW+dPp9OtF6bw=="], + "@types/verror": ["@types/verror@1.10.11", "", {}, "sha512-RlDm9K7+o5stv0Co8i8ZRGxDbrTxhJtgjqjFyVh/tXQyl/rYtTKlnTvZ88oSTeYREWurwx20Js4kTuKCsFkUtg=="], + "@types/web-push": ["@types/web-push@3.6.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-GnJmSr40H3RAnj0s34FNTcJi1hmWFV5KXugE0mYWnYhgTAHLJ/dJKAwDmvPJYMke0RplY2XE9LnM4hqSqKIjhQ=="], "@types/whatwg-mimetype": ["@types/whatwg-mimetype@3.0.2", "", {}, "sha512-c2AKvDT8ToxLIOUlN51gTiHXflsfIFisS4pO7pDPoKouJCESkhZnEy623gwP9laCy5lnLDAw1vAzu2vM2YLOrA=="], @@ -1368,6 +1430,8 @@ "@vitejs/plugin-react-swc": ["@vitejs/plugin-react-swc@4.3.0", "", { "dependencies": { "@rolldown/pluginutils": "1.0.0-rc.7", "@swc/core": "^1.15.11" }, "peerDependencies": { "vite": "^4 || ^5 || ^6 || ^7 || ^8" } }, "sha512-mOkXCII839dHyAt/gpoSlm28JIVDwhZ6tnG6wJxUy2bmOx7UaPjvOyIDf3SFv5s7Eo7HVaq6kRcu6YMEzt5Z7w=="], + "@xmldom/xmldom": ["@xmldom/xmldom@0.8.12", "", {}, "sha512-9k/gHF6n/pAi/9tqr3m3aqkuiNosYTurLLUtc7xQ9sxB/wm7WPygCv8GYa6mS0fLJEHhqMC1ATYhz++U/lRHqg=="], + "@xterm/addon-fit": ["@xterm/addon-fit@0.11.0", "", {}, "sha512-jYcgT6xtVYhnhgxh3QgYDnnNMYTcf8ElbxxFzX0IZo+vabQqSPAjC3c1wJrKB5E19VwQei89QCiZZP86DCPF7g=="], "@xterm/addon-web-links": ["@xterm/addon-web-links@0.12.0", "", {}, "sha512-4Smom3RPyVp7ZMYOYDoC/9eGJJJqYhnPLGGqJ6wOBfB8VxPViJNSKdgRYb8NpaM6YSelEKbA2SStD7lGyqaobw=="], @@ -1386,6 +1450,8 @@ "@zenyr/bun-pty-win32-x64": ["@zenyr/bun-pty-win32-x64@0.4.4", "", { "os": "win32", "cpu": "x64" }, "sha512-esZqEjPHPWRfAd/IZNaC4mptJ2HFdPXJQPUZVIdrwxEumL7NRoQZXVrlO7MRSO2Jrjqgna4IuQIvOKvCwJNMrg=="], + "abbrev": ["abbrev@3.0.1", "", {}, "sha512-AO2ac6pjRB3SJmGJo+v5/aK6Omggp6fsLrs6wN9bd35ulu4cCwaAU9+7ZhXjeqHVkaHThLuzH0nZr0YpCDhygg=="], + "accepts": ["accepts@1.3.8", "", { "dependencies": { "mime-types": "~2.1.34", "negotiator": "0.6.3" } }, "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw=="], "acorn": ["acorn@8.16.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw=="], @@ -1400,6 +1466,8 @@ "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="], + "ajv-keywords": ["ajv-keywords@3.5.2", "", { "peerDependencies": { "ajv": "^6.9.1" } }, "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ=="], + "anser": ["anser@2.3.5", "", {}, "sha512-vcZjxvvVoxTeR5XBNJB38oTu/7eDCZlwdz32N1eNgpyPF7j/Z7Idf+CUwQOkKKpJ7RJyjxgLHCM7vdIK0iCNMQ=="], "ansi-align": ["ansi-align@3.0.1", "", { "dependencies": { "string-width": "^4.1.0" } }, "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w=="], @@ -1416,6 +1484,10 @@ "anymatch": ["anymatch@3.1.3", "", { "dependencies": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" } }, "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw=="], + "app-builder-bin": ["app-builder-bin@5.0.0-alpha.12", "", {}, "sha512-j87o0j6LqPL3QRr8yid6c+Tt5gC7xNfYo6uQIQkorAC6MpeayVMZrEDzKmJJ/Hlv7EnOQpaRm53k6ktDYZyB6w=="], + + "app-builder-lib": ["app-builder-lib@26.8.1", "", { "dependencies": { "@develar/schema-utils": "~2.6.5", "@electron/asar": "3.4.1", "@electron/fuses": "^1.8.0", "@electron/get": "^3.0.0", "@electron/notarize": "2.5.0", "@electron/osx-sign": "1.3.3", "@electron/rebuild": "^4.0.3", "@electron/universal": "2.0.3", "@malept/flatpak-bundler": "^0.4.0", "@types/fs-extra": "9.0.13", "async-exit-hook": "^2.0.1", "builder-util": "26.8.1", "builder-util-runtime": "9.5.1", "chromium-pickle-js": "^0.2.0", "ci-info": "4.3.1", "debug": "^4.3.4", "dotenv": "^16.4.5", "dotenv-expand": "^11.0.6", "ejs": "^3.1.8", "electron-publish": "26.8.1", "fs-extra": "^10.1.0", "hosted-git-info": "^4.1.0", "isbinaryfile": "^5.0.0", "jiti": "^2.4.2", "js-yaml": "^4.1.0", "json5": "^2.2.3", "lazy-val": "^1.0.5", "minimatch": "^10.0.3", "plist": "3.1.0", "proper-lockfile": "^4.1.2", "resedit": "^1.7.0", "semver": "~7.7.3", "tar": "^7.5.7", "temp-file": "^3.4.0", "tiny-async-pool": "1.3.0", "which": "^5.0.0" }, "peerDependencies": { "dmg-builder": "26.8.1", "electron-builder-squirrel-windows": "26.8.1" } }, "sha512-p0Im/Dx5C4tmz8QEE1Yn4MkuPC8PrnlRneMhWJj7BBXQfNTJUshM/bp3lusdEsDbvvfJZpXWnYesgSLvwtM2Zw=="], + "arg": ["arg@5.0.2", "", {}, "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg=="], "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="], @@ -1432,8 +1504,12 @@ "asn1.js": ["asn1.js@5.4.1", "", { "dependencies": { "bn.js": "^4.0.0", "inherits": "^2.0.1", "minimalistic-assert": "^1.0.0", "safer-buffer": "^2.1.0" } }, "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA=="], + "assert-plus": ["assert-plus@1.0.0", "", {}, "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw=="], + "ast-types": ["ast-types@0.16.1", "", { "dependencies": { "tslib": "^2.0.1" } }, "sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg=="], + "astral-regex": ["astral-regex@2.0.0", "", {}, "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ=="], + "astring": ["astring@1.9.0", "", { "bin": { "astring": "bin/astring" } }, "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg=="], "astro": ["astro@5.17.3", "", { "dependencies": { "@astrojs/compiler": "^2.13.0", "@astrojs/internal-helpers": "0.7.5", "@astrojs/markdown-remark": "6.3.10", "@astrojs/telemetry": "3.3.0", "@capsizecss/unpack": "^4.0.0", "@oslojs/encoding": "^1.1.0", "@rollup/pluginutils": "^5.3.0", "acorn": "^8.15.0", "aria-query": "^5.3.2", "axobject-query": "^4.1.0", "boxen": "8.0.1", "ci-info": "^4.3.1", "clsx": "^2.1.1", "common-ancestor-path": "^1.0.1", "cookie": "^1.1.1", "cssesc": "^3.0.0", "debug": "^4.4.3", "deterministic-object-hash": "^2.0.2", "devalue": "^5.6.2", "diff": "^8.0.3", "dlv": "^1.1.3", "dset": "^3.1.4", "es-module-lexer": "^1.7.0", "esbuild": "^0.27.3", "estree-walker": "^3.0.3", "flattie": "^1.1.1", "fontace": "~0.4.0", "github-slugger": "^2.0.0", "html-escaper": "3.0.3", "http-cache-semantics": "^4.2.0", "import-meta-resolve": "^4.2.0", "js-yaml": "^4.1.1", "magic-string": "^0.30.21", "magicast": "^0.5.1", "mrmime": "^2.0.1", "neotraverse": "^0.6.18", "p-limit": "^6.2.0", "p-queue": "^8.1.1", "package-manager-detector": "^1.6.0", "piccolore": "^0.1.3", "picomatch": "^4.0.3", "prompts": "^2.4.2", "rehype": "^13.0.2", "semver": "^7.7.3", "shiki": "^3.21.0", "smol-toml": "^1.6.0", "svgo": "^4.0.0", "tinyexec": "^1.0.2", "tinyglobby": "^0.2.15", "tsconfck": "^3.1.6", "ultrahtml": "^1.6.0", "unifont": "~0.7.3", "unist-util-visit": "^5.0.0", "unstorage": "^1.17.4", "vfile": "^6.0.3", "vite": "^6.4.1", "vitefu": "^1.1.1", "xxhash-wasm": "^1.1.0", "yargs-parser": "^21.1.1", "yocto-spinner": "^0.2.3", "zod": "^3.25.76", "zod-to-json-schema": "^3.25.1", "zod-to-ts": "^1.2.0" }, "optionalDependencies": { "sharp": "^0.34.0" }, "bin": { "astro": "astro.js" } }, "sha512-69dcfPe8LsHzklwj+hl+vunWUbpMB6pmg35mACjetxbJeUNNys90JaBM8ZiwsPK689SAj/4Zqb1ayaANls9/MA=="], @@ -1442,8 +1518,12 @@ "async": ["async@3.2.6", "", {}, "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA=="], + "async-exit-hook": ["async-exit-hook@2.0.1", "", {}, "sha512-NW2cX8m1Q7KPA7a5M2ULQeZ2wR5qI5PAbw5L0UOMxdioVk9PMZ0h1TmyZEkPYrCvYjDlFICusOu1dlEKAAeXBw=="], + "async-function": ["async-function@1.0.0", "", {}, "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA=="], + "asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="], + "at-least-node": ["at-least-node@1.0.0", "", {}, "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg=="], "available-typed-arrays": ["available-typed-arrays@1.0.7", "", { "dependencies": { "possible-typed-array-names": "^1.0.0" } }, "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ=="], @@ -1492,6 +1572,8 @@ "boolbase": ["boolbase@1.0.0", "", {}, "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww=="], + "boolean": ["boolean@3.2.0", "", {}, "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw=="], + "bowser": ["bowser@2.14.1", "", {}, "sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg=="], "boxen": ["boxen@8.0.1", "", { "dependencies": { "ansi-align": "^3.0.1", "camelcase": "^8.0.0", "chalk": "^5.3.0", "cli-boxes": "^3.0.0", "string-width": "^7.2.0", "type-fest": "^4.21.0", "widest-line": "^5.0.0", "wrap-ansi": "^9.0.0" } }, "sha512-F3PH5k5juxom4xktynS7MoFY+NUWH5LC4CnH11YB8NPew+HLpmBLCybSAEyb2F+4pRXhuhWqFesoQd6DAyc2hw=="], @@ -1510,6 +1592,10 @@ "buffer-from": ["buffer-from@1.1.2", "", {}, "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="], + "builder-util": ["builder-util@26.8.1", "", { "dependencies": { "7zip-bin": "~5.2.0", "@types/debug": "^4.1.6", "app-builder-bin": "5.0.0-alpha.12", "builder-util-runtime": "9.5.1", "chalk": "^4.1.2", "cross-spawn": "^7.0.6", "debug": "^4.3.4", "fs-extra": "^10.1.0", "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.0", "js-yaml": "^4.1.0", "sanitize-filename": "^1.6.3", "source-map-support": "^0.5.19", "stat-mode": "^1.0.0", "temp-file": "^3.4.0", "tiny-async-pool": "1.3.0" } }, "sha512-pm1lTYbGyc90DHgCDO7eo8Rl4EqKLciayNbZqGziqnH9jrlKe8ZANGdityLZU+pJh16dfzjAx2xQq9McuIPEtw=="], + + "builder-util-runtime": ["builder-util-runtime@9.5.1", "", { "dependencies": { "debug": "^4.3.4", "sax": "^1.2.4" } }, "sha512-qt41tMfgHTllhResqM5DcnHyDIWNgzHvuY2jDcYP9iaGpkWxTUzV6GQjDeLnlR1/DtdlcsWQbA7sByMpmJFTLQ=="], + "bun-types": ["bun-types@1.3.9", "", { "dependencies": { "@types/node": "*" } }, "sha512-+UBWWOakIP4Tswh0Bt0QD0alpTY8cb5hvgiYeWCMet9YukHbzuruIEeXC2D7nMJPB12kbh8C7XJykSexEqGKJg=="], "bundle-name": ["bundle-name@4.1.0", "", { "dependencies": { "run-applescript": "^7.0.0" } }, "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q=="], @@ -1520,6 +1606,12 @@ "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="], + "cacache": ["cacache@19.0.1", "", { "dependencies": { "@npmcli/fs": "^4.0.0", "fs-minipass": "^3.0.0", "glob": "^10.2.2", "lru-cache": "^10.0.1", "minipass": "^7.0.3", "minipass-collect": "^2.0.1", "minipass-flush": "^1.0.5", "minipass-pipeline": "^1.2.4", "p-map": "^7.0.2", "ssri": "^12.0.0", "tar": "^7.4.3", "unique-filename": "^4.0.0" } }, "sha512-hdsUxulXCi5STId78vRVYEtDAjq99ICAUktLTeTYsLoTE6Z8dS0c8pWNCxwdrk9YfJeobDZc2Y186hD/5ZQgFQ=="], + + "cacheable-lookup": ["cacheable-lookup@5.0.4", "", {}, "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA=="], + + "cacheable-request": ["cacheable-request@7.0.4", "", { "dependencies": { "clone-response": "^1.0.2", "get-stream": "^5.1.0", "http-cache-semantics": "^4.0.0", "keyv": "^4.0.0", "lowercase-keys": "^2.0.0", "normalize-url": "^6.0.1", "responselike": "^2.0.0" } }, "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg=="], + "call-bind": ["call-bind@1.0.8", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.0", "es-define-property": "^1.0.0", "get-intrinsic": "^1.2.4", "set-function-length": "^1.2.2" } }, "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww=="], "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="], @@ -1552,6 +1644,8 @@ "chownr": ["chownr@3.0.0", "", {}, "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g=="], + "chromium-pickle-js": ["chromium-pickle-js@0.2.0", "", {}, "sha512-1R5Fho+jBq0DDydt+/vHWj5KJNJCKdARKOCwZUen84I5BreWoLqRLANH1U87eJy1tiASPtMnGqJJq0ZsLoRPOw=="], + "ci-info": ["ci-info@4.4.0", "", {}, "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg=="], "citty": ["citty@0.1.6", "", { "dependencies": { "consola": "^3.2.3" } }, "sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ=="], @@ -1566,10 +1660,16 @@ "cli-spinners": ["cli-spinners@2.9.2", "", {}, "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg=="], + "cli-truncate": ["cli-truncate@2.1.0", "", { "dependencies": { "slice-ansi": "^3.0.0", "string-width": "^4.2.0" } }, "sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg=="], + "cli-width": ["cli-width@4.1.0", "", {}, "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ=="], "cliui": ["cliui@8.0.1", "", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" } }, "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ=="], + "clone": ["clone@1.0.4", "", {}, "sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg=="], + + "clone-response": ["clone-response@1.0.3", "", { "dependencies": { "mimic-response": "^1.0.0" } }, "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA=="], + "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="], "cluster-key-slot": ["cluster-key-slot@1.1.2", "", {}, "sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA=="], @@ -1590,6 +1690,8 @@ "colorette": ["colorette@2.0.20", "", {}, "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w=="], + "combined-stream": ["combined-stream@1.0.8", "", { "dependencies": { "delayed-stream": "~1.0.0" } }, "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg=="], + "comma-separated-tokens": ["comma-separated-tokens@2.0.3", "", {}, "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg=="], "commander": ["commander@12.1.0", "", {}, "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA=="], @@ -1600,6 +1702,10 @@ "commondir": ["commondir@1.0.1", "", {}, "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg=="], + "compare-version": ["compare-version@0.1.2", "", {}, "sha512-pJDh5/4wrEnXX/VWRZvruAGHkzKdr46z11OlTPN+VrATlWWhSKewNCJ1futCO5C7eJB3nPMFZA1LeYtcFboZ2A=="], + + "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="], + "concurrently": ["concurrently@9.2.1", "", { "dependencies": { "chalk": "4.1.2", "rxjs": "7.8.2", "shell-quote": "1.8.3", "supports-color": "8.1.1", "tree-kill": "1.2.2", "yargs": "17.7.2" }, "bin": { "conc": "dist/bin/concurrently.js", "concurrently": "dist/bin/concurrently.js" } }, "sha512-fsfrO0MxV64Znoy8/l1vVIjjHa29SZyyqPgQBwhiDcaW8wJc2W3XWVOGx4M3oJBnv/zdUZIIp1gDeS98GzP8Ng=="], "confbox": ["confbox@0.2.4", "", {}, "sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ=="], @@ -1620,12 +1726,18 @@ "core-js-compat": ["core-js-compat@3.48.0", "", { "dependencies": { "browserslist": "^4.28.1" } }, "sha512-OM4cAF3D6VtH/WkLtWvyNC56EZVXsZdU3iqaMG2B4WvYrlqU831pc4UtG5yp0sE9z8Y02wVN7PjW5Zf9Gt0f1Q=="], + "core-util-is": ["core-util-is@1.0.2", "", {}, "sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ=="], + "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="], "cose-base": ["cose-base@1.0.3", "", { "dependencies": { "layout-base": "^1.0.0" } }, "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg=="], "cosmiconfig": ["cosmiconfig@9.0.0", "", { "dependencies": { "env-paths": "^2.2.1", "import-fresh": "^3.3.0", "js-yaml": "^4.1.0", "parse-json": "^5.2.0" }, "peerDependencies": { "typescript": ">=4.9.5" }, "optionalPeers": ["typescript"] }, "sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg=="], + "crc": ["crc@3.8.0", "", { "dependencies": { "buffer": "^5.1.0" } }, "sha512-iX3mfgcTMIq3ZKLIsVFAbv7+Mc10kxabAGQb8HvjA1o3T1PIYprbakQ65d3I+2HGHt6nSKkM9PYjgoJO2KcFBQ=="], + + "cross-dirname": ["cross-dirname@0.1.0", "", {}, "sha512-+R08/oI0nl3vfPcqftZRpytksBXDzOUveBq/NBVx0sUp1axwzPQrKinNx5yd5sxPu8j1wIy8AfnVQ+5eFdha6Q=="], + "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="], "crossws": ["crossws@0.3.5", "", { "dependencies": { "uncrypto": "^0.1.3" } }, "sha512-ojKiDvcmByhwa8YYqbQI/hg7MEU0NC03+pSdEq4ZUnZR9xXpwk7E43SMNGkn+JxJGPFtNvQ48+vV2p+P1ml5PA=="], @@ -1750,6 +1862,10 @@ "default-browser-id": ["default-browser-id@5.0.1", "", {}, "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q=="], + "defaults": ["defaults@1.0.4", "", { "dependencies": { "clone": "^1.0.2" } }, "sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A=="], + + "defer-to-connect": ["defer-to-connect@2.0.1", "", {}, "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg=="], + "define-data-property": ["define-data-property@1.1.4", "", { "dependencies": { "es-define-property": "^1.0.0", "es-errors": "^1.3.0", "gopd": "^1.0.1" } }, "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A=="], "define-lazy-prop": ["define-lazy-prop@3.0.0", "", {}, "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg=="], @@ -1762,6 +1878,8 @@ "delaunator": ["delaunator@5.0.1", "", { "dependencies": { "robust-predicates": "^3.0.2" } }, "sha512-8nvh+XBe96aCESrGOqMp/84b13H9cdKbG5P2ejQCh4d4sK9RL4371qou9drQjMhvnPmhWl5hnmqbEE0fXr9Xnw=="], + "delayed-stream": ["delayed-stream@1.0.0", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="], + "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="], "dequal": ["dequal@2.0.3", "", {}, "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="], @@ -1770,6 +1888,8 @@ "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="], + "detect-node": ["detect-node@2.1.0", "", {}, "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g=="], + "detect-node-es": ["detect-node-es@1.1.0", "", {}, "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ=="], "deterministic-object-hash": ["deterministic-object-hash@2.0.2", "", { "dependencies": { "base-64": "^1.0.0" } }, "sha512-KxektNH63SrbfUyDiwXqRb1rLwKt33AmMv+5Nhsw1kqZ13SJBRTgZHtGbE+hH3a1mVW1cz+4pqSWVPAtLVXTzQ=="], @@ -1780,10 +1900,16 @@ "diff": ["diff@8.0.3", "", {}, "sha512-qejHi7bcSD4hQAZE0tNAawRK1ZtafHDmMTMkrrIGgSLl7hTnQHmKCeB45xAcbfTqK2zowkM3j3bHt/4b/ARbYQ=="], + "dir-compare": ["dir-compare@4.2.0", "", { "dependencies": { "minimatch": "^3.0.5", "p-limit": "^3.1.0 " } }, "sha512-2xMCmOoMrdQIPHdsTawECdNPwlVFB9zGcz3kuhmBO6U3oU+UQjsue0i8ayLKpgBcm+hcXPMVSGUN9d+pvJ6+VQ=="], + "direction": ["direction@2.0.1", "", { "bin": { "direction": "cli.js" } }, "sha512-9S6m9Sukh1cZNknO1CWAr2QAWsbKLafQiyM5gZ7VgXHeuaoUwffKN4q6NC4A/Mf9iiPlOXQEKW/Mv/mh9/3YFA=="], "dlv": ["dlv@1.1.3", "", {}, "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA=="], + "dmg-builder": ["dmg-builder@26.8.1", "", { "dependencies": { "app-builder-lib": "26.8.1", "builder-util": "26.8.1", "fs-extra": "^10.1.0", "iconv-lite": "^0.6.2", "js-yaml": "^4.1.0" }, "optionalDependencies": { "dmg-license": "^1.0.11" } }, "sha512-glMJgnTreo8CFINujtAhCgN96QAqApDMZ8Vl1r8f0QT8QprvC1UCltV4CcWj20YoIyLZx6IUskaJZ0NV8fokcg=="], + + "dmg-license": ["dmg-license@1.0.11", "", { "dependencies": { "@types/plist": "^3.0.1", "@types/verror": "^1.10.3", "ajv": "^6.10.0", "crc": "^3.8.0", "iconv-corefoundation": "^1.1.7", "plist": "^3.0.4", "smart-buffer": "^4.0.2", "verror": "^1.10.0" }, "os": "darwin", "bin": { "dmg-license": "bin/dmg-license.js" } }, "sha512-ZdzmqwKmECOWJpqefloC5OJy1+WZBBse5+MR88z9g9Zn4VY+WYUkAyojmhzJckH5YbbZGcYIuGAkY5/Ys5OM2Q=="], + "dom-accessibility-api": ["dom-accessibility-api@0.5.16", "", {}, "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg=="], "dom-serializer": ["dom-serializer@2.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.2", "entities": "^4.2.0" } }, "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg=="], @@ -1798,6 +1924,8 @@ "dotenv": ["dotenv@17.3.1", "", {}, "sha512-IO8C/dzEb6O3F9/twg6ZLXz164a2fhTnEWb95H23Dm4OuN+92NmEAlTrupP9VW6Jm3sO26tQlqyvyi4CsnY9GA=="], + "dotenv-expand": ["dotenv-expand@11.0.7", "", { "dependencies": { "dotenv": "^16.4.5" } }, "sha512-zIHwmZPRshsCdpMDyVsqGmgyP0yT8GAgXUnkdAoJisxvf33k7yO6OuoKmcTGuXPWSsm8Oh88nZicRLA9Y0rUeA=="], + "drizzle-orm": ["drizzle-orm@0.41.0", "", { "peerDependencies": { "@aws-sdk/client-rds-data": ">=3", "@cloudflare/workers-types": ">=4", "@electric-sql/pglite": ">=0.2.0", "@libsql/client": ">=0.10.0", "@libsql/client-wasm": ">=0.10.0", "@neondatabase/serverless": ">=0.10.0", "@op-engineering/op-sqlite": ">=2", "@opentelemetry/api": "^1.4.1", "@planetscale/database": ">=1", "@prisma/client": "*", "@tidbcloud/serverless": "*", "@types/better-sqlite3": "*", "@types/pg": "*", "@types/sql.js": "*", "@vercel/postgres": ">=0.8.0", "@xata.io/client": "*", "better-sqlite3": ">=7", "bun-types": "*", "expo-sqlite": ">=14.0.0", "gel": ">=2", "knex": "*", "kysely": "*", "mysql2": ">=2", "pg": ">=8", "postgres": ">=3", "sql.js": ">=1", "sqlite3": ">=5" }, "optionalPeers": ["@aws-sdk/client-rds-data", "@cloudflare/workers-types", "@electric-sql/pglite", "@libsql/client", "@libsql/client-wasm", "@neondatabase/serverless", "@op-engineering/op-sqlite", "@opentelemetry/api", "@planetscale/database", "@prisma/client", "@tidbcloud/serverless", "@types/better-sqlite3", "@types/pg", "@types/sql.js", "@vercel/postgres", "@xata.io/client", "better-sqlite3", "bun-types", "expo-sqlite", "gel", "knex", "kysely", "mysql2", "pg", "postgres", "sql.js", "sqlite3"] }, "sha512-7A4ZxhHk9gdlXmTdPj/lREtP+3u8KvZ4yEN6MYVxBzZGex5Wtdc+CWSbu7btgF6TB0N+MNPrvW7RKBbxJchs/Q=="], "dset": ["dset@3.1.4", "", {}, "sha512-2QF/g9/zTaPDc3BjNcVTGoBbXBgYfMTTceLaYcFJ/W9kggFUkhxD/hMEeuLKbugyef9SqAx8cpgwlIP/jinUTA=="], @@ -1814,12 +1942,26 @@ "ejs": ["ejs@3.1.10", "", { "dependencies": { "jake": "^10.8.5" }, "bin": { "ejs": "bin/cli.js" } }, "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA=="], + "electron": ["electron@35.7.5", "", { "dependencies": { "@electron/get": "^2.0.0", "@types/node": "^22.7.7", "extract-zip": "^2.0.1" }, "bin": { "electron": "cli.js" } }, "sha512-dnL+JvLraKZl7iusXTVTGYs10TKfzUi30uEDTqsmTm0guN9V2tbOjTzyIZbh9n3ygUjgEYyo+igAwMRXIi3IPw=="], + + "electron-builder": ["electron-builder@26.8.1", "", { "dependencies": { "app-builder-lib": "26.8.1", "builder-util": "26.8.1", "builder-util-runtime": "9.5.1", "chalk": "^4.1.2", "ci-info": "^4.2.0", "dmg-builder": "26.8.1", "fs-extra": "^10.1.0", "lazy-val": "^1.0.5", "simple-update-notifier": "2.0.0", "yargs": "^17.6.2" }, "bin": { "electron-builder": "cli.js", "install-app-deps": "install-app-deps.js" } }, "sha512-uWhx1r74NGpCagG0ULs/P9Nqv2nsoo+7eo4fLUOB8L8MdWltq9odW/uuLXMFCDGnPafknYLZgjNX0ZIFRzOQAw=="], + + "electron-builder-squirrel-windows": ["electron-builder-squirrel-windows@26.8.1", "", { "dependencies": { "app-builder-lib": "26.8.1", "builder-util": "26.8.1", "electron-winstaller": "5.4.0" } }, "sha512-o288fIdgPLHA76eDrFADHPoo7VyGkDCYbLV1GzndaMSAVBoZrGvM9m2IehdcVMzdAZJ2eV9bgyissQXHv5tGzA=="], + + "electron-log": ["electron-log@5.4.3", "", {}, "sha512-sOUsM3LjZdugatazSQ/XTyNcw8dfvH1SYhXWiJyfYodAAKOZdHs0txPiLDXFzOZbhXgAgshQkshH2ccq0feyLQ=="], + + "electron-publish": ["electron-publish@26.8.1", "", { "dependencies": { "@types/fs-extra": "^9.0.11", "builder-util": "26.8.1", "builder-util-runtime": "9.5.1", "chalk": "^4.1.2", "form-data": "^4.0.5", "fs-extra": "^10.1.0", "lazy-val": "^1.0.5", "mime": "^2.5.2" } }, "sha512-q+jrSTIh/Cv4eGZa7oVR+grEJo/FoLMYBAnSL5GCtqwUpr1T+VgKB/dn1pnzxIxqD8S/jP1yilT9VrwCqINR4w=="], + "electron-to-chromium": ["electron-to-chromium@1.5.286", "", {}, "sha512-9tfDXhJ4RKFNerfjdCcZfufu49vg620741MNs26a9+bhLThdB+plgMeou98CAaHu/WATj2iHOOHTp1hWtABj2A=="], + "electron-winstaller": ["electron-winstaller@5.4.0", "", { "dependencies": { "@electron/asar": "^3.2.1", "debug": "^4.1.1", "fs-extra": "^7.0.1", "lodash": "^4.17.21", "temp": "^0.9.0" }, "optionalDependencies": { "@electron/windows-sign": "^1.1.2" } }, "sha512-bO3y10YikuUwUuDUQRM4KfwNkKhnpVO7IPdbsrejwN9/AABJzzTQ4GeHwyzNSrVO+tEH3/Np255a3sVZpZDjvg=="], + "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="], + "encoding": ["encoding@0.1.13", "", { "dependencies": { "iconv-lite": "^0.6.2" } }, "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A=="], + "end-of-stream": ["end-of-stream@1.4.5", "", { "dependencies": { "once": "^1.4.0" } }, "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg=="], "engine.io": ["engine.io@6.6.5", "", { "dependencies": { "@types/cors": "^2.8.12", "@types/node": ">=10.0.0", "accepts": "~1.3.4", "base64id": "2.0.0", "cookie": "~0.7.2", "cors": "~2.8.5", "debug": "~4.4.1", "engine.io-parser": "~5.2.1", "ws": "~8.18.3" } }, "sha512-2RZdgEbXmp5+dVbRm0P7HQUImZpICccJy7rN7Tv+SFa55pH+lxnuw6/K1ZxxBfHoYpSkHLAO92oa8O4SwFXA2A=="], @@ -1834,6 +1976,8 @@ "env-paths": ["env-paths@2.2.1", "", {}, "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A=="], + "err-code": ["err-code@2.0.3", "", {}, "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA=="], + "error-ex": ["error-ex@1.3.4", "", { "dependencies": { "is-arrayish": "^0.2.1" } }, "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ=="], "es-abstract": ["es-abstract@1.24.1", "", { "dependencies": { "array-buffer-byte-length": "^1.0.2", "arraybuffer.prototype.slice": "^1.0.4", "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "call-bound": "^1.0.4", "data-view-buffer": "^1.0.2", "data-view-byte-length": "^1.0.2", "data-view-byte-offset": "^1.0.1", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "es-set-tostringtag": "^2.1.0", "es-to-primitive": "^1.3.0", "function.prototype.name": "^1.1.8", "get-intrinsic": "^1.3.0", "get-proto": "^1.0.1", "get-symbol-description": "^1.1.0", "globalthis": "^1.0.4", "gopd": "^1.2.0", "has-property-descriptors": "^1.0.2", "has-proto": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "internal-slot": "^1.1.0", "is-array-buffer": "^3.0.5", "is-callable": "^1.2.7", "is-data-view": "^1.0.2", "is-negative-zero": "^2.0.3", "is-regex": "^1.2.1", "is-set": "^2.0.3", "is-shared-array-buffer": "^1.0.4", "is-string": "^1.1.1", "is-typed-array": "^1.1.15", "is-weakref": "^1.1.1", "math-intrinsics": "^1.1.0", "object-inspect": "^1.13.4", "object-keys": "^1.1.1", "object.assign": "^4.1.7", "own-keys": "^1.0.1", "regexp.prototype.flags": "^1.5.4", "safe-array-concat": "^1.1.3", "safe-push-apply": "^1.0.0", "safe-regex-test": "^1.1.0", "set-proto": "^1.0.0", "stop-iteration-iterator": "^1.1.0", "string.prototype.trim": "^1.2.10", "string.prototype.trimend": "^1.0.9", "string.prototype.trimstart": "^1.0.8", "typed-array-buffer": "^1.0.3", "typed-array-byte-length": "^1.0.3", "typed-array-byte-offset": "^1.0.4", "typed-array-length": "^1.0.7", "unbox-primitive": "^1.1.0", "which-typed-array": "^1.1.19" } }, "sha512-zHXBLhP+QehSSbsS9Pt23Gg964240DPd6QCf8WpkqEXxQ7fhdZzYsocOr5u7apWonsS5EjZDmTF+/slGMyasvw=="], @@ -1852,6 +1996,8 @@ "es-toolkit": ["es-toolkit@1.45.1", "", {}, "sha512-/jhoOj/Fx+A+IIyDNOvO3TItGmlMKhtX8ISAHKE90c4b/k1tqaqEZ+uUqfpU8DMnW5cgNJv606zS55jGvza0Xw=="], + "es6-error": ["es6-error@4.1.1", "", {}, "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg=="], + "esast-util-from-estree": ["esast-util-from-estree@2.0.0", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "devlop": "^1.0.0", "estree-util-visit": "^2.0.0", "unist-util-position-from-estree": "^2.0.0" } }, "sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ=="], "esast-util-from-js": ["esast-util-from-js@2.0.1", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "acorn": "^8.0.0", "esast-util-from-estree": "^2.0.0", "vfile-message": "^4.0.0" } }, "sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw=="], @@ -1864,7 +2010,7 @@ "escape-html": ["escape-html@1.0.3", "", {}, "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="], - "escape-string-regexp": ["escape-string-regexp@5.0.0", "", {}, "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="], + "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="], "escodegen": ["escodegen@2.1.0", "", { "dependencies": { "esprima": "^4.0.1", "estraverse": "^5.2.0", "esutils": "^2.0.2" }, "optionalDependencies": { "source-map": "~0.6.1" }, "bin": { "esgenerate": "bin/esgenerate.js", "escodegen": "bin/escodegen.js" } }, "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w=="], @@ -1900,6 +2046,8 @@ "expand-template": ["expand-template@2.0.3", "", {}, "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg=="], + "exponential-backoff": ["exponential-backoff@3.1.3", "", {}, "sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA=="], + "express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.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", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="], "express-rate-limit": ["express-rate-limit@8.2.1", "", { "dependencies": { "ip-address": "10.0.1" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g=="], @@ -1912,6 +2060,8 @@ "extract-zip": ["extract-zip@2.0.1", "", { "dependencies": { "debug": "^4.1.1", "get-stream": "^5.1.0", "yauzl": "^2.10.0" }, "optionalDependencies": { "@types/yauzl": "^2.9.1" }, "bin": { "extract-zip": "cli.js" } }, "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg=="], + "extsprintf": ["extsprintf@1.4.1", "", {}, "sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA=="], + "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="], "fast-glob": ["fast-glob@3.3.3", "", { "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" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="], @@ -1958,6 +2108,8 @@ "foreground-child": ["foreground-child@3.3.1", "", { "dependencies": { "cross-spawn": "^7.0.6", "signal-exit": "^4.0.1" } }, "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw=="], + "form-data": ["form-data@4.0.5", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w=="], + "formdata-polyfill": ["formdata-polyfill@4.0.10", "", { "dependencies": { "fetch-blob": "^3.1.2" } }, "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g=="], "forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="], @@ -1968,7 +2120,11 @@ "fs-constants": ["fs-constants@1.0.0", "", {}, "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="], - "fs-extra": ["fs-extra@11.3.3", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg=="], + "fs-extra": ["fs-extra@10.1.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ=="], + + "fs-minipass": ["fs-minipass@3.0.3", "", { "dependencies": { "minipass": "^7.0.3" } }, "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw=="], + + "fs.realpath": ["fs.realpath@1.0.0", "", {}, "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="], "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], @@ -2024,6 +2180,8 @@ "glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="], + "global-agent": ["global-agent@3.0.0", "", { "dependencies": { "boolean": "^3.0.1", "es6-error": "^4.1.1", "matcher": "^3.0.0", "roarr": "^2.15.3", "semver": "^7.3.2", "serialize-error": "^7.0.1" } }, "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q=="], + "globalthis": ["globalthis@1.0.4", "", { "dependencies": { "define-properties": "^1.2.1", "gopd": "^1.0.1" } }, "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ=="], "google-auth-library": ["google-auth-library@10.5.0", "", { "dependencies": { "base64-js": "^1.3.0", "ecdsa-sig-formatter": "^1.0.11", "gaxios": "^7.0.0", "gcp-metadata": "^8.0.0", "google-logging-utils": "^1.0.0", "gtoken": "^8.0.0", "jws": "^4.0.0" } }, "sha512-7ABviyMOlX5hIVD60YOfHw4/CxOfBhyduaYB+wbFWCWoni4N7SLcV46hrVRktuBbZjFC9ONyqamZITN7q3n32w=="], @@ -2032,6 +2190,8 @@ "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="], + "got": ["got@11.8.6", "", { "dependencies": { "@sindresorhus/is": "^4.0.0", "@szmarczak/http-timer": "^4.0.5", "@types/cacheable-request": "^6.0.1", "@types/responselike": "^1.0.0", "cacheable-lookup": "^5.0.3", "cacheable-request": "^7.0.2", "decompress-response": "^6.0.0", "http2-wrapper": "^1.0.0-beta.5.2", "lowercase-keys": "^2.0.0", "p-cancelable": "^2.0.0", "responselike": "^2.0.0" } }, "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g=="], + "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="], "graphql": ["graphql@16.12.0", "", {}, "sha512-DKKrynuQRne0PNpEbzuEdHlYOMksHSUI8Zc9Unei5gTsMNA2/vMpoMz/yKba50pejK56qj98qM0SjYxAKi13gQ=="], @@ -2128,6 +2288,8 @@ "http-proxy-agent": ["http-proxy-agent@7.0.2", "", { "dependencies": { "agent-base": "^7.1.0", "debug": "^4.3.4" } }, "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig=="], + "http2-wrapper": ["http2-wrapper@1.0.3", "", { "dependencies": { "quick-lru": "^5.1.1", "resolve-alpn": "^1.0.0" } }, "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg=="], + "http_ece": ["http_ece@1.2.0", "", {}, "sha512-JrF8SSLVmcvc5NducxgyOrKXe3EsyHMgBFgSaIUGmArKe+rwr0uphRkRXvwiom3I+fpIfoItveHrfudL8/rxuA=="], "https-proxy-agent": ["https-proxy-agent@7.0.6", "", { "dependencies": { "agent-base": "^7.1.2", "debug": "4" } }, "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw=="], @@ -2138,6 +2300,8 @@ "ico-endec": ["ico-endec@0.1.6", "", {}, "sha512-ZdLU38ZoED3g1j3iEyzcQj+wAkY2xfWNkymszfJPoxucIUhK7NayQ+/C4Kv0nDFMIsbtbEHldv3V8PU494/ueQ=="], + "iconv-corefoundation": ["iconv-corefoundation@1.1.7", "", { "dependencies": { "cli-truncate": "^2.1.0", "node-addon-api": "^1.6.3" }, "os": "darwin" }, "sha512-T10qvkw0zz4wnm560lOEg0PovVqUXuOFhhHAkixw8/sycy7TJt7v/RrkEKEQnAw2viPSJu6iAkErxnzR0g8PpQ=="], + "iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="], "idb": ["idb@7.1.1", "", {}, "sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ=="], @@ -2152,6 +2316,10 @@ "import-meta-resolve": ["import-meta-resolve@4.2.0", "", {}, "sha512-Iqv2fzaTQN28s/FwZAoFq0ZSs/7hMAHJVX+w8PZl3cY19Pxk6jFFalxQoIfW2826i/fDLXv8IiEZRIT0lDuWcg=="], + "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="], + + "inflight": ["inflight@1.0.6", "", { "dependencies": { "once": "^1.3.0", "wrappy": "1" } }, "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA=="], + "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="], "ini": ["ini@1.3.8", "", {}, "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="], @@ -2258,6 +2426,8 @@ "isarray": ["isarray@2.0.5", "", {}, "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw=="], + "isbinaryfile": ["isbinaryfile@5.0.7", "", {}, "sha512-gnWD14Jh3FzS3CPhF0AxNOJ8CxqeblPTADzI38r0wt8ZyQl5edpy75myt08EG2oKvpyiqSqsx+Wkz9vtkbTqYQ=="], + "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="], "jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="], @@ -2276,6 +2446,8 @@ "json-bigint": ["json-bigint@1.0.0", "", { "dependencies": { "bignumber.js": "^9.0.0" } }, "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ=="], + "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="], + "json-parse-even-better-errors": ["json-parse-even-better-errors@2.3.1", "", {}, "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="], "json-schema": ["json-schema@0.4.0", "", {}, "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA=="], @@ -2286,6 +2458,8 @@ "json-schema-typed": ["json-schema-typed@8.0.2", "", {}, "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA=="], + "json-stringify-safe": ["json-stringify-safe@5.0.1", "", {}, "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA=="], + "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="], "jsonfile": ["jsonfile@6.2.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg=="], @@ -2298,6 +2472,8 @@ "katex": ["katex@0.16.28", "", { "dependencies": { "commander": "^8.3.0" }, "bin": { "katex": "cli.js" } }, "sha512-YHzO7721WbmAL6Ov1uzN/l5mY5WWWhJBSW+jq4tkfZfsxmo1hu6frS0EOswvjBUnWE6NtjEs48SFn5CQESRLZg=="], + "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="], + "khroma": ["khroma@2.1.0", "", {}, "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw=="], "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="], @@ -2314,6 +2490,8 @@ "layout-base": ["layout-base@1.0.2", "", {}, "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg=="], + "lazy-val": ["lazy-val@1.0.5", "", {}, "sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q=="], + "lefthook": ["lefthook@2.1.1", "", { "optionalDependencies": { "lefthook-darwin-arm64": "2.1.1", "lefthook-darwin-x64": "2.1.1", "lefthook-freebsd-arm64": "2.1.1", "lefthook-freebsd-x64": "2.1.1", "lefthook-linux-arm64": "2.1.1", "lefthook-linux-x64": "2.1.1", "lefthook-openbsd-arm64": "2.1.1", "lefthook-openbsd-x64": "2.1.1", "lefthook-windows-arm64": "2.1.1", "lefthook-windows-x64": "2.1.1" }, "bin": { "lefthook": "bin/index.js" } }, "sha512-Tl9h9c+sG3ShzTHKuR3LAIblnnh+Mgxnm2Ul7yu9cu260Z27LEbO3V6Zw4YZFP59/2rlD42pt/llYsQCkkCFzw=="], "lefthook-darwin-arm64": ["lefthook-darwin-arm64@2.1.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-O/RS1j03/Fnq5zCzEb2r7UOBsqPeBuf1C5pMkIJcO4TSE6hf3rhLUkcorKc2M5ni/n5zLGtzQUXHV08/fSAT3Q=="], @@ -2388,6 +2566,8 @@ "loose-envify": ["loose-envify@1.4.0", "", { "dependencies": { "js-tokens": "^3.0.0 || ^4.0.0" }, "bin": { "loose-envify": "cli.js" } }, "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q=="], + "lowercase-keys": ["lowercase-keys@2.0.0", "", {}, "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA=="], + "lru-cache": ["lru-cache@7.18.3", "", {}, "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA=="], "lucide-react": ["lucide-react@0.575.0", "", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-VuXgKZrk0uiDlWjGGXmKV6MSk9Yy4l10qgVvzGn2AWBx1Ylt0iBexKOAoA6I7JO3m+M9oeovJd3yYENfkUbOeg=="], @@ -2400,12 +2580,16 @@ "make-dir": ["make-dir@3.1.0", "", { "dependencies": { "semver": "^6.0.0" } }, "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw=="], + "make-fetch-happen": ["make-fetch-happen@14.0.3", "", { "dependencies": { "@npmcli/agent": "^3.0.0", "cacache": "^19.0.1", "http-cache-semantics": "^4.1.1", "minipass": "^7.0.2", "minipass-fetch": "^4.0.0", "minipass-flush": "^1.0.5", "minipass-pipeline": "^1.2.4", "negotiator": "^1.0.0", "proc-log": "^5.0.0", "promise-retry": "^2.0.1", "ssri": "^12.0.0" } }, "sha512-QMjGbFTP0blj97EeidG5hk/QhKQ3T4ICckQGLgz38QF7Vgbk6e6FTARN8KhKxyBbWn8R0HU+bnw8aSoFPD4qtQ=="], + "markdown-extensions": ["markdown-extensions@2.0.0", "", {}, "sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q=="], "markdown-table": ["markdown-table@3.0.4", "", {}, "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw=="], "marked": ["marked@15.0.12", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-8dD6FusOQSrpv9Z1rdNMdlSgQOIP880DHqnohobOmYLElGEqAL/JvxvuxZO16r4HtjTlfPRDC1hbvxC9dPN2nA=="], + "matcher": ["matcher@3.0.0", "", { "dependencies": { "escape-string-regexp": "^4.0.0" } }, "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng=="], + "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="], "mdast-util-definitions": ["mdast-util-definitions@6.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-scTllyX6pnYNZH/AIp/0ePz6s4cZtARxImwoPJ7kS42n+MnVsI4XbnG6d4ibehRIldYMWM2LD7ImQblVhUejVQ=="], @@ -2540,6 +2724,8 @@ "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="], + "mime": ["mime@2.6.0", "", { "bin": { "mime": "cli.js" } }, "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg=="], + "mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="], "mime-types": ["mime-types@3.0.2", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A=="], @@ -2558,8 +2744,20 @@ "minipass": ["minipass@7.1.3", "", {}, "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A=="], + "minipass-collect": ["minipass-collect@2.0.1", "", { "dependencies": { "minipass": "^7.0.3" } }, "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw=="], + + "minipass-fetch": ["minipass-fetch@4.0.1", "", { "dependencies": { "minipass": "^7.0.3", "minipass-sized": "^1.0.3", "minizlib": "^3.0.1" }, "optionalDependencies": { "encoding": "^0.1.13" } }, "sha512-j7U11C5HXigVuutxebFadoYBbd7VSdZWggSe64NVdvWNBqGAiXPL2QVCehjmw7lY1oF9gOllYbORh+hiNgfPgQ=="], + + "minipass-flush": ["minipass-flush@1.0.7", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-TbqTz9cUwWyHS2Dy89P3ocAGUGxKjjLuR9z8w4WUTGAVgEj17/4nhgo2Du56i0Fm3Pm30g4iA8Lcqctc76jCzA=="], + + "minipass-pipeline": ["minipass-pipeline@1.2.4", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A=="], + + "minipass-sized": ["minipass-sized@1.0.3", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g=="], + "minizlib": ["minizlib@3.1.0", "", { "dependencies": { "minipass": "^7.1.2" } }, "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw=="], + "mkdirp": ["mkdirp@0.5.6", "", { "dependencies": { "minimist": "^1.2.6" }, "bin": { "mkdirp": "bin/cmd.js" } }, "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw=="], + "mkdirp-classic": ["mkdirp-classic@0.5.3", "", {}, "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A=="], "mlly": ["mlly@1.8.0", "", { "dependencies": { "acorn": "^8.15.0", "pathe": "^2.0.3", "pkg-types": "^1.3.1", "ufo": "^1.6.1" } }, "sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g=="], @@ -2596,7 +2794,11 @@ "nlcst-to-string": ["nlcst-to-string@4.0.0", "", { "dependencies": { "@types/nlcst": "^2.0.0" } }, "sha512-YKLBCcUYKAg0FNlOBT6aI91qFmSiFKiluk655WzPF+DDMA02qIyy8uiRqI8QXtcFpEvll12LpL5MXqEmAZ+dcA=="], - "node-abi": ["node-abi@3.87.0", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-+CGM1L1CgmtheLcBuleyYOn7NWPVu0s0EJH2C4puxgEZb9h8QpR9G2dBfZJOAUhi7VQxuBPMd0hiISWcTyiYyQ=="], + "node-abi": ["node-abi@4.28.0", "", { "dependencies": { "semver": "^7.6.3" } }, "sha512-Qfp5XZL1cJDOabOT8H5gnqMTmM4NjvYzHp4I/Kt/Sl76OVkOBBHRFlPspGV0hYvMoqQsypFjT/Yp7Km0beXW9g=="], + + "node-addon-api": ["node-addon-api@1.7.2", "", {}, "sha512-ibPK3iA+vaY1eEjESkQkM0BbCqFOaZMiXRTtdB0u7b4djtY6JnsjvPdUHVMg6xQt3B8fpTTWHI9A+ADjM9frzg=="], + + "node-api-version": ["node-api-version@0.2.1", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-2xP/IGGMmmSQpI1+O/k72jF/ykvZ89JeuKX3TLJAYPDVLUalrshrLHkeVcCCZqG/eEa635cr8IBYzgnDvM2O8Q=="], "node-domexception": ["node-domexception@1.0.0", "", {}, "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ=="], @@ -2604,12 +2806,18 @@ "node-fetch-native": ["node-fetch-native@1.6.7", "", {}, "sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q=="], + "node-gyp": ["node-gyp@11.5.0", "", { "dependencies": { "env-paths": "^2.2.0", "exponential-backoff": "^3.1.1", "graceful-fs": "^4.2.6", "make-fetch-happen": "^14.0.3", "nopt": "^8.0.0", "proc-log": "^5.0.0", "semver": "^7.3.5", "tar": "^7.4.3", "tinyglobby": "^0.2.12", "which": "^5.0.0" }, "bin": { "node-gyp": "bin/node-gyp.js" } }, "sha512-ra7Kvlhxn5V9Slyus0ygMa2h+UqExPqUIkfk7Pc8QTLT956JLSy51uWFwHtIYy0vI8cB4BDhc/S03+880My/LQ=="], + "node-mock-http": ["node-mock-http@1.0.4", "", {}, "sha512-8DY+kFsDkNXy1sJglUfuODx1/opAGJGyrTuFqEoN90oRc2Vk0ZbD4K2qmKXBBEhZQzdKHIVfEJpDU8Ak2NJEvQ=="], "node-releases": ["node-releases@2.0.27", "", {}, "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA=="], + "nopt": ["nopt@8.1.0", "", { "dependencies": { "abbrev": "^3.0.0" }, "bin": { "nopt": "bin/nopt.js" } }, "sha512-ieGu42u/Qsa4TFktmaKEwM6MQH0pOWnaB3htzh0JRtx84+Mebc0cbZYN5bC+6WTZ4+77xrL9Pn5m7CV6VIkV7A=="], + "normalize-path": ["normalize-path@3.0.0", "", {}, "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA=="], + "normalize-url": ["normalize-url@6.1.0", "", {}, "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A=="], + "notepack.io": ["notepack.io@3.0.1", "", {}, "sha512-TKC/8zH5pXIAMVQio2TvVDTtPRX+DJPHDqjRbxogtFiByHyzKmy96RA0JtCQJ+WouyyL4A10xomQzgbUT+1jCg=="], "npm-run-path": ["npm-run-path@6.0.0", "", { "dependencies": { "path-key": "^4.0.0", "unicorn-magic": "^0.3.0" } }, "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA=="], @@ -2652,10 +2860,14 @@ "own-keys": ["own-keys@1.0.1", "", { "dependencies": { "get-intrinsic": "^1.2.6", "object-keys": "^1.1.1", "safe-push-apply": "^1.0.0" } }, "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg=="], + "p-cancelable": ["p-cancelable@2.1.1", "", {}, "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg=="], + "p-limit": ["p-limit@6.2.0", "", { "dependencies": { "yocto-queue": "^1.1.1" } }, "sha512-kuUqqHNUqoIWp/c467RI4X6mmyuojY5jGutNU0wVTmEOOfcuwLqyMVoAi9MKi2Ak+5i9+nhmrK4ufZE8069kHA=="], "p-locate": ["p-locate@4.1.0", "", { "dependencies": { "p-limit": "^2.2.0" } }, "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A=="], + "p-map": ["p-map@7.0.4", "", {}, "sha512-tkAQEw8ysMzmkhgw8k+1U/iPhWNhykKnSk4Rd5zLoPJCuJaGRPo6YposrZgaxHKzDHdDWWZvE/Sk7hsL2X/CpQ=="], + "p-queue": ["p-queue@8.1.1", "", { "dependencies": { "eventemitter3": "^5.0.1", "p-timeout": "^6.1.2" } }, "sha512-aNZ+VfjobsWryoiPnEApGGmf5WmNsCo9xu8dfaYamG5qaLP7ClhLN6NgsFe6SwJ2UbLEBK5dv9x8Mn5+RVhMWQ=="], "p-retry": ["p-retry@4.6.2", "", { "dependencies": { "@types/retry": "0.12.0", "retry": "^0.13.1" } }, "sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ=="], @@ -2698,6 +2910,8 @@ "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="], + "path-is-absolute": ["path-is-absolute@1.0.1", "", {}, "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg=="], + "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="], "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="], @@ -2708,6 +2922,8 @@ "pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="], + "pe-library": ["pe-library@0.4.1", "", {}, "sha512-eRWB5LBz7PpDu4PUlwT0PhnQfTQJlDDdPa35urV4Osrm0t0AqQFGn+UIkU3klZvwJ8KPO3VbBFsXquA6p6kqZw=="], + "pend": ["pend@1.2.0", "", {}, "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg=="], "perfect-debounce": ["perfect-debounce@2.1.0", "", {}, "sha512-LjgdTytVFXeUgtHZr9WYViYSM/g8MkcTPYDlPa3cDqMirHjKiSZPYd6DoL7pK8AJQr+uWkQvCjHNdiMqsrJs+g=="], @@ -2746,6 +2962,8 @@ "playwright-core": ["playwright-core@1.58.2", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-yZkEtftgwS8CsfYo7nm0KE8jsvm6i/PTgVtB8DL726wNf6H2IMsDuxCpJj59KDaxCtSnrWan2AeDqM7JBaultg=="], + "plist": ["plist@3.1.0", "", { "dependencies": { "@xmldom/xmldom": "^0.8.8", "base64-js": "^1.5.1", "xmlbuilder": "^15.1.1" } }, "sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ=="], + "points-on-curve": ["points-on-curve@0.2.0", "", {}, "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A=="], "points-on-path": ["points-on-path@0.2.1", "", { "dependencies": { "path-data-parser": "0.1.0", "points-on-curve": "0.2.0" } }, "sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g=="], @@ -2766,6 +2984,8 @@ "postgres-interval": ["postgres-interval@1.2.0", "", { "dependencies": { "xtend": "^4.0.0" } }, "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ=="], + "postject": ["postject@1.0.0-alpha.6", "", { "dependencies": { "commander": "^9.4.0" }, "bin": { "postject": "dist/cli.js" } }, "sha512-b9Eb8h2eVqNE8edvKdwqkrY6O7kAwmI8kcnBv1NScolYJbo59XUF0noFq+lxbC1yN20bmC0WBEbDC5H/7ASb0A=="], + "powershell-utils": ["powershell-utils@0.1.0", "", {}, "sha512-dM0jVuXJPsDN6DvRpea484tCUaMiXWjuCn++HGTqUWzGDjv5tZkEZldAJ/UMlqRYGFrD/etByo4/xOuC/snX2A=="], "prebuild-install": ["prebuild-install@7.1.3", "", { "dependencies": { "detect-libc": "^2.0.0", "expand-template": "^2.0.3", "github-from-package": "0.0.0", "minimist": "^1.2.3", "mkdirp-classic": "^0.5.3", "napi-build-utils": "^2.0.0", "node-abi": "^3.3.0", "pump": "^3.0.0", "rc": "^1.2.7", "simple-get": "^4.0.0", "tar-fs": "^2.0.0", "tunnel-agent": "^0.6.0" }, "bin": { "prebuild-install": "bin.js" } }, "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug=="], @@ -2780,6 +3000,12 @@ "prismjs": ["prismjs@1.30.0", "", {}, "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw=="], + "proc-log": ["proc-log@5.0.0", "", {}, "sha512-Azwzvl90HaF0aCz1JrDdXQykFakSSNPaPoiZ9fm5qJIMHioDZEi7OAdRwSm6rSoPtY3Qutnm3L7ogmg3dc+wbQ=="], + + "progress": ["progress@2.0.3", "", {}, "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA=="], + + "promise-retry": ["promise-retry@2.0.1", "", { "dependencies": { "err-code": "^2.0.2", "retry": "^0.12.0" } }, "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g=="], + "prompts": ["prompts@2.4.2", "", { "dependencies": { "kleur": "^3.0.3", "sisteransi": "^1.0.5" } }, "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q=="], "prop-types": ["prop-types@15.8.1", "", { "dependencies": { "loose-envify": "^1.4.0", "object-assign": "^4.1.1", "react-is": "^16.13.1" } }, "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg=="], @@ -2806,6 +3032,8 @@ "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="], + "quick-lru": ["quick-lru@5.1.1", "", {}, "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA=="], + "radix-ui": ["radix-ui@1.4.3", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-accessible-icon": "1.1.7", "@radix-ui/react-accordion": "1.2.12", "@radix-ui/react-alert-dialog": "1.1.15", "@radix-ui/react-arrow": "1.1.7", "@radix-ui/react-aspect-ratio": "1.1.7", "@radix-ui/react-avatar": "1.1.10", "@radix-ui/react-checkbox": "1.3.3", "@radix-ui/react-collapsible": "1.1.12", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-context-menu": "2.2.16", "@radix-ui/react-dialog": "1.1.15", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-dropdown-menu": "2.1.16", "@radix-ui/react-focus-guards": "1.1.3", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-form": "0.1.8", "@radix-ui/react-hover-card": "1.1.15", "@radix-ui/react-label": "2.1.7", "@radix-ui/react-menu": "2.1.16", "@radix-ui/react-menubar": "1.1.16", "@radix-ui/react-navigation-menu": "1.2.14", "@radix-ui/react-one-time-password-field": "0.1.8", "@radix-ui/react-password-toggle-field": "0.1.3", "@radix-ui/react-popover": "1.1.15", "@radix-ui/react-popper": "1.2.8", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-progress": "1.1.7", "@radix-ui/react-radio-group": "1.3.8", "@radix-ui/react-roving-focus": "1.1.11", "@radix-ui/react-scroll-area": "1.2.10", "@radix-ui/react-select": "2.2.6", "@radix-ui/react-separator": "1.1.7", "@radix-ui/react-slider": "1.3.6", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-switch": "1.2.6", "@radix-ui/react-tabs": "1.1.13", "@radix-ui/react-toast": "1.2.15", "@radix-ui/react-toggle": "1.1.10", "@radix-ui/react-toggle-group": "1.1.11", "@radix-ui/react-toolbar": "1.1.11", "@radix-ui/react-tooltip": "1.2.8", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-escape-keydown": "1.1.1", "@radix-ui/react-use-is-hydrated": "0.1.0", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-size": "1.1.1", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-aWizCQiyeAenIdUbqEpXgRA1ya65P13NKn/W8rWkcN0OPkRDxdBVLWnIEDsS2RpwCK2nobI7oMUSmexzTDyAmA=="], "radix3": ["radix3@1.1.2", "", {}, "sha512-b484I/7b8rDEdSDKckSSBA8knMpcdsXudlE/LNL639wFoHKwLbEkQFZHWEYwDC0wa0FKUcCY+GAF73Z7wxNVFA=="], @@ -2840,6 +3068,8 @@ "react-style-singleton": ["react-style-singleton@2.2.3", "", { "dependencies": { "get-nonce": "^1.0.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ=="], + "read-binary-file-arch": ["read-binary-file-arch@1.0.6", "", { "dependencies": { "debug": "^4.3.4" }, "bin": { "read-binary-file-arch": "cli.js" } }, "sha512-BNg9EN3DD3GsDXX7Aa8O4p92sryjkmzYYgmgTAc6CA4uGLEDzFfxOxugu21akOxpcXHiEgsYkC6nPsQvLLLmEg=="], + "readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="], "readdirp": ["readdirp@5.0.0", "", {}, "sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ=="], @@ -2932,12 +3162,18 @@ "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="], + "resedit": ["resedit@1.7.2", "", { "dependencies": { "pe-library": "^0.4.1" } }, "sha512-vHjcY2MlAITJhC0eRD/Vv8Vlgmu9Sd3LX9zZvtGzU5ZImdTN3+d6e/4mnTyV8vEbyf1sgNIrWxhWlrys52OkEA=="], + "reselect": ["reselect@5.1.1", "", {}, "sha512-K/BG6eIky/SBpzfHZv/dd+9JBFiS4SWV7FIujVyJRux6e45+73RaUHXLmIR1f7WOMaQ0U1km6qwklRQxpJJY0w=="], "resolve": ["resolve@1.22.11", "", { "dependencies": { "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ=="], + "resolve-alpn": ["resolve-alpn@1.2.1", "", {}, "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g=="], + "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="], + "responselike": ["responselike@2.0.1", "", { "dependencies": { "lowercase-keys": "^2.0.0" } }, "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw=="], + "restore-cursor": ["restore-cursor@5.1.0", "", { "dependencies": { "onetime": "^7.0.0", "signal-exit": "^4.1.0" } }, "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA=="], "retext": ["retext@9.0.0", "", { "dependencies": { "@types/nlcst": "^2.0.0", "retext-latin": "^4.0.0", "retext-stringify": "^4.0.0", "unified": "^11.0.0" } }, "sha512-sbMDcpHCNjvlheSgMfEcVrZko3cDzdbe1x/e7G66dFp0Ff7Mldvi2uv6JkJQzdRcvLYE8CA8Oe8siQx8ZOgTcA=="], @@ -2956,6 +3192,8 @@ "rimraf": ["rimraf@5.0.10", "", { "dependencies": { "glob": "^10.3.7" }, "bin": { "rimraf": "dist/esm/bin.mjs" } }, "sha512-l0OE8wL34P4nJH/H2ffoaniAokM2qSmrtXHmlpvYr5AVVX8msAyW0l8NVJFDxlSK4u3Uh/f41cQheDVdnYijwQ=="], + "roarr": ["roarr@2.15.4", "", { "dependencies": { "boolean": "^3.0.1", "detect-node": "^2.0.4", "globalthis": "^1.0.1", "json-stringify-safe": "^5.0.1", "semver-compare": "^1.0.0", "sprintf-js": "^1.1.2" } }, "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A=="], + "robust-predicates": ["robust-predicates@3.0.2", "", {}, "sha512-IXgzBWvWQwE6PrDI05OvmXUIruQTcoMDzRsOd5CDvHCVLcLHMTSYvOK5Cm46kWqlV3yAbuSpBZdJ5oP5OUoStg=="], "rollup": ["rollup@4.57.1", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.57.1", "@rollup/rollup-android-arm64": "4.57.1", "@rollup/rollup-darwin-arm64": "4.57.1", "@rollup/rollup-darwin-x64": "4.57.1", "@rollup/rollup-freebsd-arm64": "4.57.1", "@rollup/rollup-freebsd-x64": "4.57.1", "@rollup/rollup-linux-arm-gnueabihf": "4.57.1", "@rollup/rollup-linux-arm-musleabihf": "4.57.1", "@rollup/rollup-linux-arm64-gnu": "4.57.1", "@rollup/rollup-linux-arm64-musl": "4.57.1", "@rollup/rollup-linux-loong64-gnu": "4.57.1", "@rollup/rollup-linux-loong64-musl": "4.57.1", "@rollup/rollup-linux-ppc64-gnu": "4.57.1", "@rollup/rollup-linux-ppc64-musl": "4.57.1", "@rollup/rollup-linux-riscv64-gnu": "4.57.1", "@rollup/rollup-linux-riscv64-musl": "4.57.1", "@rollup/rollup-linux-s390x-gnu": "4.57.1", "@rollup/rollup-linux-x64-gnu": "4.57.1", "@rollup/rollup-linux-x64-musl": "4.57.1", "@rollup/rollup-openbsd-x64": "4.57.1", "@rollup/rollup-openharmony-arm64": "4.57.1", "@rollup/rollup-win32-arm64-msvc": "4.57.1", "@rollup/rollup-win32-ia32-msvc": "4.57.1", "@rollup/rollup-win32-x64-gnu": "4.57.1", "@rollup/rollup-win32-x64-msvc": "4.57.1", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A=="], @@ -2984,14 +3222,20 @@ "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="], + "sanitize-filename": ["sanitize-filename@1.6.4", "", { "dependencies": { "truncate-utf8-bytes": "^1.0.0" } }, "sha512-9ZyI08PsvdQl2r/bBIGubpVdR3RR9sY6RDiWFPreA21C/EFlQhmgo20UZlNjZMMZNubusLhAQozkA0Od5J21Eg=="], + "sax": ["sax@1.4.4", "", {}, "sha512-1n3r/tGXO6b6VXMdFT54SHzT9ytu9yr7TaELowdYpMqY/Ao7EnlQGmAQ1+RatX7Tkkdm6hONI2owqNx2aZj5Sw=="], "scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="], "semver": ["semver@7.7.4", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="], + "semver-compare": ["semver-compare@1.0.0", "", {}, "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow=="], + "send": ["send@1.2.1", "", { "dependencies": { "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.1", "mime-types": "^3.0.2", "ms": "^2.1.3", "on-finished": "^2.4.1", "range-parser": "^1.2.1", "statuses": "^2.0.2" } }, "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ=="], + "serialize-error": ["serialize-error@7.0.1", "", { "dependencies": { "type-fest": "^0.13.1" } }, "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw=="], + "serialize-javascript": ["serialize-javascript@6.0.2", "", { "dependencies": { "randombytes": "^2.1.0" } }, "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g=="], "serve-static": ["serve-static@2.2.1", "", { "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "parseurl": "^1.3.3", "send": "^1.2.0" } }, "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw=="], @@ -3036,10 +3280,14 @@ "simple-swizzle": ["simple-swizzle@0.2.4", "", { "dependencies": { "is-arrayish": "^0.3.1" } }, "sha512-nAu1WFPQSMNr2Zn9PGSZK9AGn4t/y97lEm+MXTtUDwfP0ksAIX4nO+6ruD9Jwut4C49SB1Ws+fbXsm/yScWOHw=="], + "simple-update-notifier": ["simple-update-notifier@2.0.0", "", { "dependencies": { "semver": "^7.5.3" } }, "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w=="], + "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="], "sitemap": ["sitemap@8.0.2", "", { "dependencies": { "@types/node": "^17.0.5", "@types/sax": "^1.2.1", "arg": "^5.0.0", "sax": "^1.4.1" }, "bin": { "sitemap": "dist/cli.js" } }, "sha512-LwktpJcyZDoa0IL6KT++lQ53pbSrx2c9ge41/SeLTyqy2XUNA6uR4+P9u5IVo5lPeL2arAcOKn1aZAxoYbCKlQ=="], + "slice-ansi": ["slice-ansi@3.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "astral-regex": "^2.0.0", "is-fullwidth-code-point": "^3.0.0" } }, "sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ=="], + "smart-buffer": ["smart-buffer@4.2.0", "", {}, "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg=="], "smob": ["smob@1.6.1", "", {}, "sha512-KAkBqZl3c2GvNgNhcoyJae1aKldDW0LO279wF9bk1PnluRTETKBq0WyzRXxEhoQLk56yHaOY4JCBEKDuJIET5g=="], @@ -3070,6 +3318,12 @@ "split2": ["split2@4.2.0", "", {}, "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg=="], + "sprintf-js": ["sprintf-js@1.1.3", "", {}, "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA=="], + + "ssri": ["ssri@12.0.0", "", { "dependencies": { "minipass": "^7.0.3" } }, "sha512-S7iGNosepx9RadX82oimUkvr0Ct7IjJbEbs4mJcTxst8um95J3sDYU1RBEOvdu6oL1Wek2ODI5i4MAw+dZ6cAQ=="], + + "stat-mode": ["stat-mode@1.0.0", "", {}, "sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg=="], + "statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="], "std-env": ["std-env@3.10.0", "", {}, "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg=="], @@ -3124,6 +3378,8 @@ "stylis": ["stylis@4.3.6", "", {}, "sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ=="], + "sumchecker": ["sumchecker@3.0.1", "", { "dependencies": { "debug": "^4.1.0" } }, "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg=="], + "supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="], "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="], @@ -3144,8 +3400,12 @@ "tar-stream": ["tar-stream@2.2.0", "", { "dependencies": { "bl": "^4.0.3", "end-of-stream": "^1.4.1", "fs-constants": "^1.0.0", "inherits": "^2.0.3", "readable-stream": "^3.1.1" } }, "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ=="], + "temp": ["temp@0.9.4", "", { "dependencies": { "mkdirp": "^0.5.1", "rimraf": "~2.6.2" } }, "sha512-yYrrsWnrXMcdsnu/7YMYAofM1ktpL5By7vZhf15CrXijWWrEYZks5AXBudalfSWJLlnen/QUJUB5aoB0kqZUGA=="], + "temp-dir": ["temp-dir@2.0.0", "", {}, "sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg=="], + "temp-file": ["temp-file@3.4.0", "", { "dependencies": { "async-exit-hook": "^2.0.1", "fs-extra": "^10.0.0" } }, "sha512-C5tjlC/HCtVUOi3KWVokd4vHVViOmGjtLwIh4MuzPo/nMYTV/p1urt3RnMz2IWXDdKEGJH3k5+KPxtqRsUYGtg=="], + "tempy": ["tempy@0.6.0", "", { "dependencies": { "is-stream": "^2.0.0", "temp-dir": "^2.0.0", "type-fest": "^0.16.0", "unique-string": "^2.0.0" } }, "sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw=="], "terser": ["terser@5.46.0", "", { "dependencies": { "@jridgewell/source-map": "^0.3.3", "acorn": "^8.15.0", "commander": "^2.20.0", "source-map-support": "~0.5.20" }, "bin": { "terser": "bin/terser" } }, "sha512-jTwoImyr/QbOWFFso3YoU3ik0jBBDJ6JTOQiy/J2YxVJdZCc+5u7skhNwiOR3FQIygFqVUPHl7qbbxtjW2K3Qg=="], @@ -3154,6 +3414,8 @@ "thenify-all": ["thenify-all@1.6.0", "", { "dependencies": { "thenify": ">= 3.1.0 < 4" } }, "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA=="], + "tiny-async-pool": ["tiny-async-pool@1.3.0", "", { "dependencies": { "semver": "^5.5.0" } }, "sha512-01EAw5EDrcVrdgyCLgoSPvqznC0sVxDSVeiOz09FUpjh71G79VCqneOr+xvt7T1r76CF6ZZfPjHorN2+d+3mqA=="], + "tiny-inflate": ["tiny-inflate@1.0.3", "", {}, "sha512-pkY1fj1cKHb2seWDy0B16HeWyczlJA9/WW3u3c4z/NiWDsO3DOU5D7nhTLE9CF0yXv/QZFY7sEJmj24dK+Rrqw=="], "tiny-invariant": ["tiny-invariant@1.3.3", "", {}, "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg=="], @@ -3168,6 +3430,8 @@ "tmp": ["tmp@0.2.5", "", {}, "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow=="], + "tmp-promise": ["tmp-promise@3.0.3", "", { "dependencies": { "tmp": "^0.2.0" } }, "sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ=="], + "to-data-view": ["to-data-view@1.1.0", "", {}, "sha512-1eAdufMg6mwgmlojAx3QeMnzB/BTVp7Tbndi3U7ftcT2zCZadjxkkmLmd97zmaxWi+sgGcgWrokmpEoy0Dn0vQ=="], "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="], @@ -3186,6 +3450,8 @@ "trough": ["trough@2.2.0", "", {}, "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw=="], + "truncate-utf8-bytes": ["truncate-utf8-bytes@1.0.2", "", { "dependencies": { "utf8-byte-length": "^1.0.1" } }, "sha512-95Pu1QXQvruGEhv62XCMO3Mm90GscOCClvrIUwCM0PYOXK3kaF3l3sIHxx71ThJfcbM2O5Au6SO3AWCSEfW4mQ=="], + "ts-algebra": ["ts-algebra@2.0.0", "", {}, "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw=="], "ts-dedent": ["ts-dedent@2.2.0", "", {}, "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ=="], @@ -3238,7 +3504,7 @@ "undici": ["undici@7.22.0", "", {}, "sha512-RqslV2Us5BrllB+JeiZnK4peryVTndy9Dnqq62S3yYRRTj0tFQCwEniUy2167skdGOy3vqRzEvl1Dm4sV2ReDg=="], - "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="], "unicode-canonical-property-names-ecmascript": ["unicode-canonical-property-names-ecmascript@2.0.1", "", {}, "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg=="], @@ -3254,6 +3520,10 @@ "unifont": ["unifont@0.7.4", "", { "dependencies": { "css-tree": "^3.1.0", "ofetch": "^1.5.1", "ohash": "^2.0.11" } }, "sha512-oHeis4/xl42HUIeHuNZRGEvxj5AaIKR+bHPNegRq5LV1gdc3jundpONbjglKpihmJf+dswygdMJn3eftGIMemg=="], + "unique-filename": ["unique-filename@4.0.0", "", { "dependencies": { "unique-slug": "^5.0.0" } }, "sha512-XSnEewXmQ+veP7xX2dS5Q4yZAvO40cBN2MWkJ7D/6sW4Dg6wYBNwM1Vrnz1FhH5AdeLIlUXRI9e28z1YZi71NQ=="], + + "unique-slug": ["unique-slug@5.0.0", "", { "dependencies": { "imurmurhash": "^0.1.4" } }, "sha512-9OdaqO5kwqR+1kVgHAhsp5vPNU0hnxRa26rBFNfNgM7M6pNtgzeBn3s/xbyCQL3dcjzOatcef6UUHpB/6MaETg=="], + "unique-string": ["unique-string@2.0.0", "", { "dependencies": { "crypto-random-string": "^2.0.0" } }, "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg=="], "unist-util-find-after": ["unist-util-find-after@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ=="], @@ -3288,6 +3558,8 @@ "update-browserslist-db": ["update-browserslist-db@1.2.3", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w=="], + "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="], + "use-callback-ref": ["use-callback-ref@1.3.3", "", { "dependencies": { "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg=="], "use-sidecar": ["use-sidecar@1.1.3", "", { "dependencies": { "detect-node-es": "^1.1.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ=="], @@ -3296,6 +3568,8 @@ "use-sync-external-store": ["use-sync-external-store@1.6.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w=="], + "utf8-byte-length": ["utf8-byte-length@1.0.5", "", {}, "sha512-Xn0w3MtiQ6zoz2vFyUVruaCL53O/DwUvkEeOvj+uulMm0BkUGYWmBYVyElqZaSLhY6ZD0ulfU3aBra2aVT4xfA=="], + "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="], "uuid": ["uuid@8.3.2", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="], @@ -3304,6 +3578,8 @@ "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="], + "verror": ["verror@1.10.1", "", { "dependencies": { "assert-plus": "^1.0.0", "core-util-is": "1.0.2", "extsprintf": "^1.2.0" } }, "sha512-veufcmxri4e3XSrT0xwfUR7kguIkaxBeosDg00yDWhk49wdwkSUrvvsm7nc75e1PUyvIeZj6nS8VQRYz2/S4Xg=="], + "vfile": ["vfile@6.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile-message": "^4.0.0" } }, "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q=="], "vfile-location": ["vfile-location@5.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile": "^6.0.0" } }, "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg=="], @@ -3330,6 +3606,8 @@ "vscode-uri": ["vscode-uri@3.1.0", "", {}, "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ=="], + "wcwidth": ["wcwidth@1.0.1", "", { "dependencies": { "defaults": "^1.0.3" } }, "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg=="], + "web-namespaces": ["web-namespaces@2.0.1", "", {}, "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ=="], "web-push": ["web-push@3.6.7", "", { "dependencies": { "asn1.js": "^5.3.0", "http_ece": "1.2.0", "https-proxy-agent": "^7.0.0", "jws": "^4.0.0", "minimist": "^1.2.5" }, "bin": { "web-push": "src/cli.js" } }, "sha512-OpiIUe8cuGjrj3mMBFWY+e4MMIkW3SVT+7vEIjvD9kejGUypv8GPDf84JdPWskK8zMRIJ6xYGm+Kxr8YkPyA0A=="], @@ -3400,6 +3678,8 @@ "wsl-utils": ["wsl-utils@0.1.0", "", { "dependencies": { "is-wsl": "^3.1.0" } }, "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw=="], + "xmlbuilder": ["xmlbuilder@15.1.1", "", {}, "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg=="], + "xmlhttprequest-ssl": ["xmlhttprequest-ssl@2.1.2", "", {}, "sha512-TEU+nJVUUnA4CYJFLvK5X9AOeH4KvDvhIfm0vV1GaQRtchnG0hgK5p8hw/xjv8cunWYCsiPCSDzObPyhEwq3KQ=="], "xtend": ["xtend@4.0.2", "", {}, "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="], @@ -3474,6 +3754,8 @@ "@better-auth/cli/chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="], + "@develar/schema-utils/ajv": ["ajv@6.14.0", "", { "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" } }, "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw=="], + "@dotenvx/dotenvx/commander": ["commander@11.1.0", "", {}, "sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ=="], "@dotenvx/dotenvx/execa": ["execa@5.1.1", "", { "dependencies": { "cross-spawn": "^7.0.3", "get-stream": "^6.0.0", "human-signals": "^2.1.0", "is-stream": "^2.0.0", "merge-stream": "^2.0.0", "npm-run-path": "^4.0.1", "onetime": "^5.1.2", "signal-exit": "^3.0.3", "strip-final-newline": "^2.0.0" } }, "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg=="], @@ -3484,6 +3766,30 @@ "@ecies/ciphers/@noble/ciphers": ["@noble/ciphers@1.3.0", "", {}, "sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw=="], + "@electron/asar/commander": ["commander@5.1.0", "", {}, "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg=="], + + "@electron/asar/glob": ["glob@7.2.3", "", { "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" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="], + + "@electron/asar/minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="], + + "@electron/fuses/fs-extra": ["fs-extra@9.1.0", "", { "dependencies": { "at-least-node": "^1.0.0", "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ=="], + + "@electron/get/fs-extra": ["fs-extra@8.1.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^4.0.0", "universalify": "^0.1.0" } }, "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g=="], + + "@electron/get/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], + + "@electron/notarize/fs-extra": ["fs-extra@9.1.0", "", { "dependencies": { "at-least-node": "^1.0.0", "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ=="], + + "@electron/osx-sign/isbinaryfile": ["isbinaryfile@4.0.10", "", {}, "sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw=="], + + "@electron/rebuild/ora": ["ora@5.4.1", "", { "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" } }, "sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ=="], + + "@electron/universal/fs-extra": ["fs-extra@11.3.3", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg=="], + + "@electron/universal/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], + + "@electron/windows-sign/fs-extra": ["fs-extra@11.3.3", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg=="], + "@inquirer/core/signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="], "@inquirer/core/wrap-ansi": ["wrap-ansi@6.2.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA=="], @@ -3492,6 +3798,8 @@ "@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="], + "@malept/flatpak-bundler/fs-extra": ["fs-extra@9.1.0", "", { "dependencies": { "at-least-node": "^1.0.0", "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ=="], + "@mariozechner/pi-ai/chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="], "@mariozechner/pi-coding-agent/chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="], @@ -3502,6 +3810,8 @@ "@noble/curves/@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="], + "@npmcli/agent/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="], + "@pizzapi/ui/motion": ["motion@12.34.3", "", { "dependencies": { "framer-motion": "^12.34.3", "tslib": "^2.4.0" }, "peerDependencies": { "@emotion/is-prop-valid": "*", "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" }, "optionalPeers": ["@emotion/is-prop-valid", "react", "react-dom"] }, "sha512-xZIkBGO7v/Uvm+EyaqYd+9IpXu0sZqLywVlGdCFrrMiaO9JI4Kx51mO9KlHSWwll+gZUVY5OJsWgYI5FywJ/tw=="], "@radix-ui/react-alert-dialog/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="], @@ -3564,10 +3874,44 @@ "@ts-morph/common/minimatch": ["minimatch@10.2.2", "", { "dependencies": { "brace-expansion": "^5.0.2" } }, "sha512-+G4CpNBxa5MprY+04MbgOw1v7So6n5JY166pFi9KfYwT78fxScCeSNQSNzp6dpPSW2rONOps6Ocam1wFhCgoVw=="], + "@types/cacheable-request/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "@types/cors/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "@types/fs-extra/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "@types/keyv/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "@types/pg/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "@types/plist/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "@types/responselike/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "@types/sax/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "@types/web-push/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "@types/ws/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "@types/yauzl/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + "accepts/mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="], + "ajv-keywords/ajv": ["ajv@6.14.0", "", { "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" } }, "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw=="], + "anymatch/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="], + "app-builder-lib/@electron/get": ["@electron/get@3.1.0", "", { "dependencies": { "debug": "^4.1.1", "env-paths": "^2.2.0", "fs-extra": "^8.1.0", "got": "^11.8.5", "progress": "^2.0.3", "semver": "^6.2.0", "sumchecker": "^3.0.1" }, "optionalDependencies": { "global-agent": "^3.0.0" } }, "sha512-F+nKc0xW+kVbBRhFzaMgPy3KwmuNTYX1fx6+FxxoSnNgwYX6LD7AKBTWkU0MQ6IBoe7dz069CNkR673sPAgkCQ=="], + + "app-builder-lib/ci-info": ["ci-info@4.3.1", "", {}, "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA=="], + + "app-builder-lib/dotenv": ["dotenv@16.6.1", "", {}, "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow=="], + + "app-builder-lib/hosted-git-info": ["hosted-git-info@4.1.0", "", { "dependencies": { "lru-cache": "^6.0.0" } }, "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA=="], + + "app-builder-lib/which": ["which@5.0.0", "", { "dependencies": { "isexe": "^3.1.1" }, "bin": { "node-which": "bin/which.js" } }, "sha512-JEdGzHwwkrbWoGOlIHqQ5gtprKGOenpDHpxE9zVR1bWbOtYRyPPHMe9FaP6x61CmNaTThSkb0DAJte5jD+DmzQ=="], + "astro/sharp": ["sharp@0.34.5", "", { "dependencies": { "@img/colour": "^1.0.0", "detect-libc": "^2.1.2", "semver": "^7.7.3" }, "optionalDependencies": { "@img/sharp-darwin-arm64": "0.34.5", "@img/sharp-darwin-x64": "0.34.5", "@img/sharp-libvips-darwin-arm64": "1.2.4", "@img/sharp-libvips-darwin-x64": "1.2.4", "@img/sharp-libvips-linux-arm": "1.2.4", "@img/sharp-libvips-linux-arm64": "1.2.4", "@img/sharp-libvips-linux-ppc64": "1.2.4", "@img/sharp-libvips-linux-riscv64": "1.2.4", "@img/sharp-libvips-linux-s390x": "1.2.4", "@img/sharp-libvips-linux-x64": "1.2.4", "@img/sharp-libvips-linuxmusl-arm64": "1.2.4", "@img/sharp-libvips-linuxmusl-x64": "1.2.4", "@img/sharp-linux-arm": "0.34.5", "@img/sharp-linux-arm64": "0.34.5", "@img/sharp-linux-ppc64": "0.34.5", "@img/sharp-linux-riscv64": "0.34.5", "@img/sharp-linux-s390x": "0.34.5", "@img/sharp-linux-x64": "0.34.5", "@img/sharp-linuxmusl-arm64": "0.34.5", "@img/sharp-linuxmusl-x64": "0.34.5", "@img/sharp-wasm32": "0.34.5", "@img/sharp-win32-arm64": "0.34.5", "@img/sharp-win32-ia32": "0.34.5", "@img/sharp-win32-x64": "0.34.5" } }, "sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg=="], "astro/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="], @@ -3580,6 +3924,12 @@ "boxen/string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="], + "bun-types/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "cacache/glob": ["glob@10.5.0", "", { "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" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="], + + "cacache/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="], + "chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="], "chevrotain-allstar/chevrotain": ["chevrotain@11.1.1", "", { "dependencies": { "@chevrotain/cst-dts-gen": "11.1.1", "@chevrotain/gast": "11.1.1", "@chevrotain/regexp-to-ast": "11.1.1", "@chevrotain/types": "11.1.1", "@chevrotain/utils": "11.1.1", "lodash-es": "4.17.23" } }, "sha512-f0yv5CPKaFxfsPTBzX7vGuim4oIC1/gcS7LUGdBSwl2dU6+FON6LVUksdOo1qJjoUvXNn45urgh8C+0a24pACQ=="], @@ -3590,6 +3940,8 @@ "cliui/wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="], + "clone-response/mimic-response": ["mimic-response@1.0.1", "", {}, "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ=="], + "cmdk/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.4", "", { "dependencies": { "@radix-ui/react-slot": "1.2.4" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-9hQc4+GNVtJAIEPEqlYqW5RiYdrr8ea5XQ0ZOnD6fgru+83kqT15mq2OCcbe8KnjRZl5vF3ks69AKz3kh1jrhg=="], "csso/css-tree": ["css-tree@2.2.1", "", { "dependencies": { "mdn-data": "2.0.28", "source-map-js": "^1.0.1" } }, "sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA=="], @@ -3606,12 +3958,28 @@ "degenerator/ast-types": ["ast-types@0.13.4", "", { "dependencies": { "tslib": "^2.0.1" } }, "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w=="], + "dir-compare/minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="], + + "dir-compare/p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="], + + "dmg-builder/iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="], + + "dmg-license/ajv": ["ajv@6.14.0", "", { "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" } }, "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw=="], + "dom-serializer/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="], + "dotenv-expand/dotenv": ["dotenv@16.6.1", "", {}, "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow=="], + "eciesjs/@noble/ciphers": ["@noble/ciphers@1.3.0", "", {}, "sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw=="], "eciesjs/@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="], + "electron-winstaller/fs-extra": ["fs-extra@7.0.1", "", { "dependencies": { "graceful-fs": "^4.1.2", "jsonfile": "^4.0.0", "universalify": "^0.1.0" } }, "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw=="], + + "encoding/iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="], + + "engine.io/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + "engine.io/cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="], "engine.io/ws": ["ws@8.18.3", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg=="], @@ -3634,10 +4002,14 @@ "foreground-child/signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="], + "form-data/mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="], + "get-uri/data-uri-to-buffer": ["data-uri-to-buffer@6.0.2", "", {}, "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw=="], "glob/minimatch": ["minimatch@10.2.2", "", { "dependencies": { "brace-expansion": "^5.0.2" } }, "sha512-+G4CpNBxa5MprY+04MbgOw1v7So6n5JY166pFi9KfYwT78fxScCeSNQSNzp6dpPSW2rONOps6Ocam1wFhCgoVw=="], + "happy-dom/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + "hast-util-from-html/parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="], "hast-util-raw/parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="], @@ -3654,16 +4026,28 @@ "make-dir/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], + "make-fetch-happen/negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="], + + "mdast-util-find-and-replace/escape-string-regexp": ["escape-string-regexp@5.0.0", "", {}, "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="], + "mermaid/marked": ["marked@16.4.2", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA=="], "mermaid/uuid": ["uuid@11.1.0", "", { "bin": { "uuid": "dist/esm/bin/uuid" } }, "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A=="], "micromatch/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="], + "minipass-flush/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="], + + "minipass-pipeline/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="], + + "minipass-sized/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="], + "mlly/pkg-types": ["pkg-types@1.3.1", "", { "dependencies": { "confbox": "^0.1.8", "mlly": "^1.7.4", "pathe": "^2.0.1" } }, "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ=="], "msw/type-fest": ["type-fest@5.4.4", "", { "dependencies": { "tagged-tag": "^1.0.0" } }, "sha512-JnTrzGu+zPV3aXIUhnyWJj4z/wigMsdYajGLIYakqyOW1nPllzXEJee0QQbHj+CTIQtXGlAjuK0UY+2xTyjVAw=="], + "node-gyp/which": ["which@5.0.0", "", { "dependencies": { "isexe": "^3.1.1" }, "bin": { "node-which": "bin/which.js" } }, "sha512-JEdGzHwwkrbWoGOlIHqQ5gtprKGOenpDHpxE9zVR1bWbOtYRyPPHMe9FaP6x61CmNaTThSkb0DAJte5jD+DmzQ=="], + "npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="], "nypm/citty": ["citty@0.2.1", "", {}, "sha512-kEV95lFBhQgtogAPlQfJJ0WGVSokvLr/UEoFPiKKOXF7pl98HfUVUD0ejsuTCld/9xH9vogSywZ5KqHzXrZpqg=="], @@ -3688,6 +4072,10 @@ "postcss-nested/postcss-selector-parser": ["postcss-selector-parser@6.1.2", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg=="], + "postject/commander": ["commander@9.5.0", "", {}, "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ=="], + + "prebuild-install/node-abi": ["node-abi@3.87.0", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-+CGM1L1CgmtheLcBuleyYOn7NWPVu0s0EJH2C4puxgEZb9h8QpR9G2dBfZJOAUhi7VQxuBPMd0hiISWcTyiYyQ=="], + "pretty-format/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], "pretty-format/ansi-styles": ["ansi-styles@5.2.0", "", {}, "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA=="], @@ -3696,6 +4084,8 @@ "prompts/kleur": ["kleur@3.0.3", "", {}, "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w=="], + "protobufjs/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + "radix-ui/@radix-ui/react-label": ["@radix-ui/react-label@2.1.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-YT1GqPSL8kJn20djelMX7/cTRp/Y9w5IZHvfxQTVHrOqa2yMl7i/UfMqKRU5V7mEyKTrUVgJXhNQPVCG8PBLoQ=="], "radix-ui/@radix-ui/react-separator": ["@radix-ui/react-separator@1.1.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-0HEb8R9E8A+jZjvmFCy/J4xhbXy3TV+9XSnGJ3KvTtjlIUy/YQ/p6UYZvi7YbeoeXdyU9+Y3scizK6hkY37baA=="], @@ -3710,10 +4100,14 @@ "router/path-to-regexp": ["path-to-regexp@8.3.0", "", {}, "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA=="], + "serialize-error/type-fest": ["type-fest@0.13.1", "", {}, "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg=="], + "shadcn/@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.26.0", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-Y5RmPncpiDtTXDbLKswIJzTqu2hyBKxTNsgKqKclDbhIgg1wgtf1fRuvxgTnRfcnxtvvgbIEcqUOzZrJ6iSReg=="], "shadcn/commander": ["commander@14.0.3", "", {}, "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw=="], + "shadcn/fs-extra": ["fs-extra@11.3.3", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg=="], + "shadcn/open": ["open@11.0.0", "", { "dependencies": { "default-browser": "^5.4.0", "define-lazy-prop": "^3.0.0", "is-in-ssh": "^1.0.0", "is-inside-container": "^1.0.0", "powershell-utils": "^0.1.0", "wsl-utils": "^0.3.0" } }, "sha512-smsWv2LzFjP03xmvFoJ331ss6h+jixfA4UUV/Bsiyuu4YJPfN+FIQGOIiv4w9/+MoHkfkJ22UIaQWRVFRfH6Vw=="], "shadcn/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="], @@ -3736,12 +4130,16 @@ "tar-fs/chownr": ["chownr@1.1.4", "", {}, "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg=="], + "temp/rimraf": ["rimraf@2.6.3", "", { "dependencies": { "glob": "^7.1.3" }, "bin": { "rimraf": "./bin.js" } }, "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA=="], + "tempy/is-stream": ["is-stream@2.0.1", "", {}, "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="], "tempy/type-fest": ["type-fest@0.16.0", "", {}, "sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg=="], "terser/commander": ["commander@2.20.3", "", {}, "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="], + "tiny-async-pool/semver": ["semver@5.7.2", "", { "bin": { "semver": "bin/semver" } }, "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g=="], + "unstorage/lru-cache": ["lru-cache@11.2.6", "", {}, "sha512-ESL2CrkS/2wTPfuend7Zhkzo2u0daGJ/A2VucJOgQ/C48S/zB8MMeMHSGKYpXhIjbPxfuezITkaBH1wqv00DDQ=="], "vite/esbuild": ["esbuild@0.25.12", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.12", "@esbuild/android-arm": "0.25.12", "@esbuild/android-arm64": "0.25.12", "@esbuild/android-x64": "0.25.12", "@esbuild/darwin-arm64": "0.25.12", "@esbuild/darwin-x64": "0.25.12", "@esbuild/freebsd-arm64": "0.25.12", "@esbuild/freebsd-x64": "0.25.12", "@esbuild/linux-arm": "0.25.12", "@esbuild/linux-arm64": "0.25.12", "@esbuild/linux-ia32": "0.25.12", "@esbuild/linux-loong64": "0.25.12", "@esbuild/linux-mips64el": "0.25.12", "@esbuild/linux-ppc64": "0.25.12", "@esbuild/linux-riscv64": "0.25.12", "@esbuild/linux-s390x": "0.25.12", "@esbuild/linux-x64": "0.25.12", "@esbuild/netbsd-arm64": "0.25.12", "@esbuild/netbsd-x64": "0.25.12", "@esbuild/openbsd-arm64": "0.25.12", "@esbuild/openbsd-x64": "0.25.12", "@esbuild/openharmony-arm64": "0.25.12", "@esbuild/sunos-x64": "0.25.12", "@esbuild/win32-arm64": "0.25.12", "@esbuild/win32-ia32": "0.25.12", "@esbuild/win32-x64": "0.25.12" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg=="], @@ -3776,6 +4174,8 @@ "@babel/helper-compilation-targets/lru-cache/yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="], + "@develar/schema-utils/ajv/json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], + "@dotenvx/dotenvx/execa/get-stream": ["get-stream@6.0.1", "", {}, "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg=="], "@dotenvx/dotenvx/execa/human-signals": ["human-signals@2.1.0", "", {}, "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw=="], @@ -3788,6 +4188,24 @@ "@dotenvx/dotenvx/which/isexe": ["isexe@3.1.5", "", {}, "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w=="], + "@electron/asar/minimatch/brace-expansion": ["brace-expansion@1.1.13", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w=="], + + "@electron/get/fs-extra/jsonfile": ["jsonfile@4.0.0", "", { "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg=="], + + "@electron/get/fs-extra/universalify": ["universalify@0.1.2", "", {}, "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg=="], + + "@electron/rebuild/ora/cli-cursor": ["cli-cursor@3.1.0", "", { "dependencies": { "restore-cursor": "^3.1.0" } }, "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw=="], + + "@electron/rebuild/ora/is-interactive": ["is-interactive@1.0.0", "", {}, "sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w=="], + + "@electron/rebuild/ora/is-unicode-supported": ["is-unicode-supported@0.1.0", "", {}, "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw=="], + + "@electron/rebuild/ora/log-symbols": ["log-symbols@4.1.0", "", { "dependencies": { "chalk": "^4.1.0", "is-unicode-supported": "^0.1.0" } }, "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg=="], + + "@electron/rebuild/ora/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], + + "@electron/universal/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], + "@inquirer/core/wrap-ansi/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], "@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="], @@ -3808,8 +4226,40 @@ "@rollup/plugin-replace/@rollup/pluginutils/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="], + "@types/cacheable-request/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "@types/cors/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "@types/fs-extra/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "@types/keyv/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "@types/pg/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "@types/plist/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "@types/responselike/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "@types/sax/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "@types/web-push/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "@types/ws/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "@types/yauzl/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + "accepts/mime-types/mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="], + "ajv-keywords/ajv/json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], + + "app-builder-lib/@electron/get/fs-extra": ["fs-extra@8.1.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^4.0.0", "universalify": "^0.1.0" } }, "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g=="], + + "app-builder-lib/@electron/get/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], + + "app-builder-lib/hosted-git-info/lru-cache": ["lru-cache@6.0.0", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA=="], + + "app-builder-lib/which/isexe": ["isexe@3.1.5", "", {}, "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w=="], + "astro/sharp/@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.2.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w=="], "astro/sharp/@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.2.4" }, "os": "darwin", "cpu": "x64" }, "sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw=="], @@ -3850,6 +4300,12 @@ "boxen/string-width/emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="], + "bun-types/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + + "cacache/glob/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], + + "cacache/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="], + "chevrotain-allstar/chevrotain/@chevrotain/cst-dts-gen": ["@chevrotain/cst-dts-gen@11.1.1", "", { "dependencies": { "@chevrotain/gast": "11.1.1", "@chevrotain/types": "11.1.1", "lodash-es": "4.17.23" } }, "sha512-fRHyv6/f542qQqiRGalrfJl/evD39mAvbJLCekPazhiextEatq1Jx1K/i9gSd5NNO0ds03ek0Cbo/4uVKmOBcw=="], "chevrotain-allstar/chevrotain/@chevrotain/gast": ["@chevrotain/gast@11.1.1", "", { "dependencies": { "@chevrotain/types": "11.1.1", "lodash-es": "4.17.23" } }, "sha512-Ko/5vPEYy1vn5CbCjjvnSO4U7GgxyGm+dfUZZJIWTlQFkXkyym0jFYrWEU10hyCjrA7rQtiHtBr0EaZqvHFZvg=="], @@ -3870,10 +4326,26 @@ "d3-sankey/d3-shape/d3-path": ["d3-path@1.0.9", "", {}, "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg=="], + "dir-compare/minimatch/brace-expansion": ["brace-expansion@1.1.13", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w=="], + + "dir-compare/p-limit/yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="], + + "dmg-license/ajv/json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], + + "electron-winstaller/fs-extra/jsonfile": ["jsonfile@4.0.0", "", { "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg=="], + + "electron-winstaller/fs-extra/universalify": ["universalify@0.1.2", "", {}, "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg=="], + + "engine.io/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + "express/accepts/negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="], "filelist/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], + "form-data/mime-types/mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="], + + "happy-dom/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + "hast-util-from-html/parse5/entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="], "hast-util-raw/parse5/entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="], @@ -3886,10 +4358,20 @@ "langium/chevrotain/@chevrotain/utils": ["@chevrotain/utils@11.1.1", "", {}, "sha512-71eTYMzYXYSFPrbg/ZwftSaSDld7UYlS8OQa3lNnn9jzNtpFbaReRRyghzqS7rI3CDaorqpPJJcXGHK+FE1TVQ=="], + "minipass-flush/minipass/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="], + + "minipass-pipeline/minipass/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="], + + "minipass-sized/minipass/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="], + "mlly/pkg-types/confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="], + "node-gyp/which/isexe": ["isexe@3.1.5", "", {}, "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w=="], + "ora/string-width/emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="], + "protobufjs/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + "rimraf/glob/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], "rimraf/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="], @@ -3902,6 +4384,8 @@ "string-width/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], + "temp/rimraf/glob": ["glob@7.2.3", "", { "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" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="], + "vite/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.12", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA=="], "vite/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.25.12", "", { "os": "android", "cpu": "arm" }, "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg=="], @@ -3974,24 +4458,50 @@ "@aws-crypto/util/@smithy/util-utf8/@smithy/util-buffer-from/@smithy/is-array-buffer": ["@smithy/is-array-buffer@2.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA=="], + "@electron/asar/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], + + "@electron/rebuild/ora/cli-cursor/restore-cursor": ["restore-cursor@3.1.0", "", { "dependencies": { "onetime": "^5.1.0", "signal-exit": "^3.0.2" } }, "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA=="], + + "@electron/rebuild/ora/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], + + "@electron/universal/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], + "@inquirer/core/wrap-ansi/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], "@pizzapi/ui/motion/framer-motion/motion-dom": ["motion-dom@12.34.3", "", { "dependencies": { "motion-utils": "^12.29.2" } }, "sha512-sYgFe+pR9aIM7o4fhs2aXtOI+oqlUd33N9Yoxcgo1Fv7M20sRkHtCmzE/VRNIcq7uNJ+qio+Xubt1FXH3pQ+eQ=="], + "app-builder-lib/@electron/get/fs-extra/jsonfile": ["jsonfile@4.0.0", "", { "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg=="], + + "app-builder-lib/@electron/get/fs-extra/universalify": ["universalify@0.1.2", "", {}, "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg=="], + + "app-builder-lib/hosted-git-info/lru-cache/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="], + + "cacache/glob/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], + "cli-highlight/yargs/cliui/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], "cli-highlight/yargs/cliui/wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="], + "dir-compare/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], + "filelist/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], "rimraf/glob/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], "rimraf/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="], + "temp/rimraf/glob/minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="], + "workbox-build/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@9.0.0", "", {}, "sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg=="], + "cacache/glob/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], + "cli-highlight/yargs/cliui/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], "rimraf/glob/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], + + "temp/rimraf/glob/minimatch/brace-expansion": ["brace-expansion@1.1.13", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w=="], + + "temp/rimraf/glob/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], } } diff --git a/package.json b/package.json index dcd33aa4a..41b712f7a 100644 --- a/package.json +++ b/package.json @@ -8,7 +8,8 @@ "packages/server", "packages/ui", "packages/cli", - "packages/docs" + "packages/docs", + "packages/desktop" ], "scripts": { "build": "bun run build:protocol && bun run build:tunnel && bun run build:tools && bun run build:server && bun run build:ui && bun run build:cli", @@ -29,6 +30,9 @@ "dev:server": "cd packages/server && bun run dev", "dev:ui": "cd packages/ui && bun run dev", "dev:cli": "bun packages/cli/src/index.ts", + "dev:desktop": "cd packages/desktop && bun run dev", + "build:desktop": "bun run build:ui && bun run build:server && bun run build:cli && cd packages/desktop && bun run build", + "package:desktop": "bun run build:desktop && cd packages/desktop && bun run package", "dev:runner": "bun packages/cli/src/index.ts runner", "test": "bun test packages/protocol/src packages/tunnel/src packages/server/src packages/server/tests packages/tools/src && cd packages/cli && bun test src && cd ../ui && bun test src", "typecheck": "bun packages/cli/scripts/compile-prompt.ts && tsc --build && bun run --cwd packages/protocol typecheck:tests && bun run --cwd packages/server typecheck:tests", diff --git a/packages/desktop/electron-builder.yml b/packages/desktop/electron-builder.yml new file mode 100644 index 000000000..933d1e80d --- /dev/null +++ b/packages/desktop/electron-builder.yml @@ -0,0 +1,37 @@ +appId: com.pizzapi.desktop +productName: PizzaPi +copyright: Copyright © 2026 PizzaPi + +directories: + output: release + +mac: + category: public.app-category.developer-tools + target: + - target: dir + arch: + - arm64 + icon: assets/icon.png + +files: + - dist/**/* + - assets/**/* + - package.json + # Bundle the built UI assets + - from: ../ui/dist + to: ui-dist + filter: + - "**/*" + # Bundle the built server + - from: ../server/dist + to: server-dist + filter: + - "**/*" + # Bundle the built CLI (runner) + - from: ../cli/dist + to: cli-dist + filter: + - "**/*" + +extraMetadata: + main: dist/main/index.js diff --git a/packages/desktop/package.json b/packages/desktop/package.json new file mode 100644 index 000000000..7b18909df --- /dev/null +++ b/packages/desktop/package.json @@ -0,0 +1,24 @@ +{ + "name": "@pizzapi/desktop", + "version": "0.1.0", + "private": true, + "type": "module", + "main": "dist/main/index.js", + "scripts": { + "dev": "concurrently \"bun run dev:electron\" \"bun run --cwd ../ui dev\" \"bun run --cwd ../server dev\" --kill-others-on-exit", + "dev:electron": "electron --inspect . --dev", + "build": "tsc --build", + "package": "electron-builder --mac", + "start": "electron ." + }, + "dependencies": { + "@pizzapi/protocol": "workspace:*", + "electron-log": "^5.3.0" + }, + "devDependencies": { + "electron": "^35.0.0", + "electron-builder": "^26.0.0", + "concurrently": "^9.2.1", + "typescript": "^5.7.0" + } +} diff --git a/packages/desktop/tsconfig.json b/packages/desktop/tsconfig.json new file mode 100644 index 000000000..14f0dcd39 --- /dev/null +++ b/packages/desktop/tsconfig.json @@ -0,0 +1,16 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "outDir": "dist", + "rootDir": "src", + "module": "ESNext", + "moduleResolution": "bundler", + "target": "ES2022", + "declaration": true, + "sourceMap": true + }, + "include": ["src"], + "references": [ + { "path": "../protocol" } + ] +} From 7322bc00ec05a845aa9d97ec16df97df1ea72520 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:29:20 -0400 Subject: [PATCH 04/20] feat(desktop): add config and logger modules --- packages/desktop/src/main/config.ts | 55 +++++++++++++++++++++++++++++ packages/desktop/src/main/logger.ts | 7 ++++ 2 files changed, 62 insertions(+) create mode 100644 packages/desktop/src/main/config.ts create mode 100644 packages/desktop/src/main/logger.ts diff --git a/packages/desktop/src/main/config.ts b/packages/desktop/src/main/config.ts new file mode 100644 index 000000000..0758cf2b0 --- /dev/null +++ b/packages/desktop/src/main/config.ts @@ -0,0 +1,55 @@ +import { app } from "electron"; +import { join } from "node:path"; + +/** Whether we're running in dev mode (passed via --dev flag). */ +export const isDev = process.argv.includes("--dev"); + +/** Default port for the relay server. */ +export const DEFAULT_SERVER_PORT = 3001; + +/** Vite dev server URL (used in dev mode only). */ +export const VITE_DEV_URL = "http://localhost:5173"; + +/** Path to the bundled UI dist assets (production). */ +export function getUIDistPath(): string { + if (isDev) { + return join(__dirname, "..", "..", "..", "ui", "dist"); + } + // In packaged app, electron-builder places them at ui-dist/ + return join(process.resourcesPath, "app", "ui-dist"); +} + +/** Path to the bundled server entry (production). */ +export function getServerEntryPath(): string { + if (isDev) { + return join(__dirname, "..", "..", "..", "server", "src", "index.ts"); + } + return join(process.resourcesPath, "app", "server-dist", "index.js"); +} + +/** Path to the bundled CLI entry for runner (production). */ +export function getRunnerEntryPath(): string { + if (isDev) { + return join(__dirname, "..", "..", "..", "cli", "src", "index.ts"); + } + return join(process.resourcesPath, "app", "cli-dist", "index.js"); +} + +/** App data directory. */ +export function getAppDataPath(): string { + return app.getPath("userData"); +} + +/** Logs directory. */ +export function getLogsPath(): string { + return app.getPath("logs"); +} + +/** Max restart attempts for child processes before showing error. */ +export const MAX_RESTART_ATTEMPTS = 3; + +/** Health check polling interval in ms. */ +export const HEALTH_CHECK_INTERVAL = 500; + +/** Health check timeout in ms. */ +export const HEALTH_CHECK_TIMEOUT = 30_000; diff --git a/packages/desktop/src/main/logger.ts b/packages/desktop/src/main/logger.ts new file mode 100644 index 000000000..9e20dea27 --- /dev/null +++ b/packages/desktop/src/main/logger.ts @@ -0,0 +1,7 @@ +import log from "electron-log/main"; + +log.initialize(); +log.transports.file.level = "info"; +log.transports.console.level = "debug"; + +export default log; From 8e69eaacd9fc6565875e78f6a5c2744e9af1076f Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:31:07 -0400 Subject: [PATCH 05/20] feat(desktop): add runner manager with auto-restart --- packages/desktop/src/main/runner-manager.ts | 79 +++++++++++++++++++ packages/desktop/tests/runner-manager.test.ts | 74 +++++++++++++++++ 2 files changed, 153 insertions(+) create mode 100644 packages/desktop/src/main/runner-manager.ts create mode 100644 packages/desktop/tests/runner-manager.test.ts diff --git a/packages/desktop/src/main/runner-manager.ts b/packages/desktop/src/main/runner-manager.ts new file mode 100644 index 000000000..e3adac69a --- /dev/null +++ b/packages/desktop/src/main/runner-manager.ts @@ -0,0 +1,79 @@ +import { spawn, type ChildProcess } from "node:child_process"; +import { getRunnerEntryPath, MAX_RESTART_ATTEMPTS } from "./config.js"; +import log from "./logger.js"; + +export interface RunnerManagerOptions { + serverPort: number; + isDev: boolean; +} + +export class RunnerManager { + private child: ChildProcess | null = null; + private serverPort: number; + private isDev: boolean; + private restartCount = 0; + private stopping = false; + + constructor(opts: RunnerManagerOptions) { + this.serverPort = opts.serverPort; + this.isDev = opts.isDev; + } + + /** Spawn the runner daemon. */ + start(): void { + this.stopping = false; + const entry = getRunnerEntryPath(); + log.info("Starting runner daemon..."); + + const env = { + ...process.env, + PIZZAPI_SERVER_URL: `http://localhost:${this.serverPort}`, + }; + + this.child = spawn("bun", ["run", entry, "runner"], { + env, + stdio: ["ignore", "pipe", "pipe"], + }); + + this.child.stdout?.on("data", (data: Buffer) => { + log.info(`[runner] ${data.toString().trim()}`); + }); + + this.child.stderr?.on("data", (data: Buffer) => { + log.warn(`[runner] ${data.toString().trim()}`); + }); + + this.child.on("exit", (code, signal) => { + log.info(`Runner exited: code=${code} signal=${signal}`); + this.child = null; + if (!this.stopping && this.restartCount < MAX_RESTART_ATTEMPTS) { + this.restartCount++; + log.warn(`Restarting runner (attempt ${this.restartCount}/${MAX_RESTART_ATTEMPTS})...`); + this.start(); + } + }); + } + + /** Gracefully stop the runner. */ + stop(): void { + this.stopping = true; + if (this.child) { + log.info("Stopping runner daemon..."); + this.child.kill("SIGTERM"); + this.child = null; + } + } + + /** Force-kill if still running. */ + forceKill(): void { + this.stopping = true; + if (this.child) { + this.child.kill("SIGKILL"); + this.child = null; + } + } + + isRunning(): boolean { + return this.child !== null; + } +} diff --git a/packages/desktop/tests/runner-manager.test.ts b/packages/desktop/tests/runner-manager.test.ts new file mode 100644 index 000000000..bde9f36d1 --- /dev/null +++ b/packages/desktop/tests/runner-manager.test.ts @@ -0,0 +1,74 @@ +import { describe, test, expect, mock, beforeEach } from "bun:test"; + +// Mock electron-log/main before anything imports logger +mock.module("electron-log/main", () => ({ + default: { + initialize: mock(() => {}), + info: mock(() => {}), + warn: mock(() => {}), + error: mock(() => {}), + transports: { + file: { level: "info" }, + console: { level: "debug" }, + }, + }, +})); + +// Mock electron app module (used by config.ts) +mock.module("electron", () => ({ + app: { + getPath: mock(() => "/tmp/test"), + }, +})); + +// Mock config to avoid __dirname issues in test +mock.module("../src/main/config.js", () => ({ + getRunnerEntryPath: () => "/fake/runner/index.js", + MAX_RESTART_ATTEMPTS: 3, +})); + +const mockKill = mock(() => true); +const mockStdoutOn = mock(() => {}); +const mockStderrOn = mock(() => {}); +const mockOn = mock(() => {}); + +const mockSpawn = mock(() => ({ + pid: 5678, + on: mockOn, + kill: mockKill, + stdout: { on: mockStdoutOn }, + stderr: { on: mockStderrOn }, +})); + +mock.module("node:child_process", () => ({ + spawn: mockSpawn, +})); + +describe("RunnerManager", () => { + beforeEach(() => { + mockSpawn.mockClear(); + mockKill.mockClear(); + mockOn.mockClear(); + }); + + test("start() spawns the runner daemon pointing at the local server", async () => { + const { RunnerManager } = await import("../src/main/runner-manager.js"); + const mgr = new RunnerManager({ serverPort: 3001, isDev: true }); + + mgr.start(); + + expect(mockSpawn).toHaveBeenCalled(); + expect(mgr.isRunning()).toBe(true); + }); + + test("stop() sends SIGTERM to runner", async () => { + const { RunnerManager } = await import("../src/main/runner-manager.js"); + const mgr = new RunnerManager({ serverPort: 3001, isDev: true }); + + mgr.start(); + mgr.stop(); + + expect(mockKill).toHaveBeenCalledWith("SIGTERM"); + expect(mgr.isRunning()).toBe(false); + }); +}); From fb17724c7f90f8617420152b47c72a389bfdea08 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:31:09 -0400 Subject: [PATCH 06/20] feat(desktop): add server manager with health check and auto-restart --- packages/desktop/src/main/server-manager.ts | 108 ++++++++++++++++++ packages/desktop/tests/server-manager.test.ts | 96 ++++++++++++++++ 2 files changed, 204 insertions(+) create mode 100644 packages/desktop/src/main/server-manager.ts create mode 100644 packages/desktop/tests/server-manager.test.ts diff --git a/packages/desktop/src/main/server-manager.ts b/packages/desktop/src/main/server-manager.ts new file mode 100644 index 000000000..2dc89a3cb --- /dev/null +++ b/packages/desktop/src/main/server-manager.ts @@ -0,0 +1,108 @@ +import { spawn, type ChildProcess } from "node:child_process"; +import { + getServerEntryPath, + HEALTH_CHECK_INTERVAL, + HEALTH_CHECK_TIMEOUT, + MAX_RESTART_ATTEMPTS, +} from "./config.js"; +import log from "./logger.js"; + +export interface ServerManagerOptions { + port: number; + isDev: boolean; +} + +export class ServerManager { + private child: ChildProcess | null = null; + private port: number; + private isDev: boolean; + private restartCount = 0; + private stopping = false; + + constructor(opts: ServerManagerOptions) { + this.port = opts.port; + this.isDev = opts.isDev; + } + + /** Spawn the relay server and wait for it to become healthy. */ + async start(): Promise { + this.stopping = false; + const entry = getServerEntryPath(); + log.info(`Starting relay server on port ${this.port}...`); + + const env = { + ...process.env, + PORT: String(this.port), + NODE_ENV: this.isDev ? "development" : "production", + }; + + this.child = spawn("bun", ["run", entry], { + env, + stdio: ["ignore", "pipe", "pipe"], + }); + + this.child.stdout?.on("data", (data: Buffer) => { + log.info(`[server] ${data.toString().trim()}`); + }); + + this.child.stderr?.on("data", (data: Buffer) => { + log.warn(`[server] ${data.toString().trim()}`); + }); + + this.child.on("exit", (code, signal) => { + log.info(`Server exited: code=${code} signal=${signal}`); + this.child = null; + if (!this.stopping && this.restartCount < MAX_RESTART_ATTEMPTS) { + this.restartCount++; + log.warn(`Restarting server (attempt ${this.restartCount}/${MAX_RESTART_ATTEMPTS})...`); + this.start().catch((err) => log.error("Server restart failed:", err)); + } + }); + + await this.waitForHealthy(); + this.restartCount = 0; + log.info(`Relay server healthy on port ${this.port}`); + } + + /** Poll /health until 200 or timeout. */ + private async waitForHealthy(): Promise { + const deadline = Date.now() + HEALTH_CHECK_TIMEOUT; + while (Date.now() < deadline) { + try { + const res = await fetch(`http://localhost:${this.port}/health`); + if (res.ok) return; + } catch { + // Server not ready yet + } + await new Promise((r) => setTimeout(r, HEALTH_CHECK_INTERVAL)); + } + throw new Error(`Server failed to become healthy within ${HEALTH_CHECK_TIMEOUT}ms`); + } + + /** Gracefully stop the server. */ + stop(): void { + this.stopping = true; + if (this.child) { + log.info("Stopping relay server..."); + this.child.kill("SIGTERM"); + this.child = null; + } + } + + /** Force-kill if still running. */ + forceKill(): void { + this.stopping = true; + if (this.child) { + this.child.kill("SIGKILL"); + this.child = null; + } + } + + isRunning(): boolean { + return this.child !== null; + } + + getPort(): number { + return this.port; + } +} diff --git a/packages/desktop/tests/server-manager.test.ts b/packages/desktop/tests/server-manager.test.ts new file mode 100644 index 000000000..660852887 --- /dev/null +++ b/packages/desktop/tests/server-manager.test.ts @@ -0,0 +1,96 @@ +import { describe, test, expect, mock, beforeEach } from "bun:test"; + +// Mock electron-log/main before anything imports logger +mock.module("electron-log/main", () => { + const noop = () => {}; + const log = { + info: noop, + warn: noop, + error: noop, + debug: noop, + initialize: noop, + transports: { + file: { level: "info" }, + console: { level: "debug" }, + }, + }; + return { default: log }; +}); + +// Mock electron app module used by config +mock.module("electron", () => ({ + app: { + getPath: () => "/tmp/test", + }, +})); + +// Mock config to avoid __dirname issues in test context +mock.module("../src/main/config.js", () => ({ + getServerEntryPath: () => "/fake/server/index.ts", + HEALTH_CHECK_INTERVAL: 10, + HEALTH_CHECK_TIMEOUT: 1000, + MAX_RESTART_ATTEMPTS: 3, + isDev: true, +})); + +// Mock child_process.spawn +const mockKill = mock(() => true); +const mockSpawn = mock(() => ({ + pid: 1234, + on: mock(() => {}), + kill: mockKill, + stdout: { on: mock(() => {}) }, + stderr: { on: mock(() => {}) }, +})); + +mock.module("node:child_process", () => ({ + spawn: mockSpawn, +})); + +describe("ServerManager", () => { + beforeEach(() => { + mockSpawn.mockClear(); + mockKill.mockClear(); + }); + + test("start() spawns a child process with the correct entry path", async () => { + const { ServerManager } = await import("../src/main/server-manager.js"); + const mgr = new ServerManager({ port: 3001, isDev: true }); + + // Mock fetch for health check + const originalFetch = globalThis.fetch; + globalThis.fetch = mock(() => + Promise.resolve(new Response("ok", { status: 200 })) + ) as any; + + await mgr.start(); + + expect(mockSpawn).toHaveBeenCalled(); + expect(mgr.isRunning()).toBe(true); + + globalThis.fetch = originalFetch; + }); + + test("stop() sends SIGTERM to the child process", async () => { + const { ServerManager } = await import("../src/main/server-manager.js"); + const mgr = new ServerManager({ port: 3001, isDev: true }); + + const originalFetch = globalThis.fetch; + globalThis.fetch = mock(() => + Promise.resolve(new Response("ok", { status: 200 })) + ) as any; + + await mgr.start(); + mgr.stop(); + + expect(mgr.isRunning()).toBe(false); + + globalThis.fetch = originalFetch; + }); + + test("getPort() returns the configured port", async () => { + const { ServerManager } = await import("../src/main/server-manager.js"); + const mgr = new ServerManager({ port: 3042, isDev: true }); + expect(mgr.getPort()).toBe(3042); + }); +}); From def52f6419d7806e35984794e8c17502ad3f2374 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:32:06 -0400 Subject: [PATCH 07/20] feat(desktop): add auto-launch login item support --- packages/desktop/src/main/auto-launch.ts | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 packages/desktop/src/main/auto-launch.ts diff --git a/packages/desktop/src/main/auto-launch.ts b/packages/desktop/src/main/auto-launch.ts new file mode 100644 index 000000000..e4b0d6bf7 --- /dev/null +++ b/packages/desktop/src/main/auto-launch.ts @@ -0,0 +1,16 @@ +// packages/desktop/src/main/auto-launch.ts +import { app } from "electron"; +import log from "./logger.js"; + +export function getAutoLaunchEnabled(): boolean { + const settings = app.getLoginItemSettings(); + return settings.openAtLogin; +} + +export function setAutoLaunchEnabled(enabled: boolean): void { + log.info(`Setting auto-launch: ${enabled}`); + app.setLoginItemSettings({ + openAtLogin: enabled, + openAsHidden: true, // Start minimized to tray + }); +} From d15bb6fb76493a4cca3028f3364d9461e91cec41 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:32:09 -0400 Subject: [PATCH 08/20] feat(desktop): add native notification helpers --- packages/desktop/src/main/notifications.ts | 56 ++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 packages/desktop/src/main/notifications.ts diff --git a/packages/desktop/src/main/notifications.ts b/packages/desktop/src/main/notifications.ts new file mode 100644 index 000000000..56a3aeb79 --- /dev/null +++ b/packages/desktop/src/main/notifications.ts @@ -0,0 +1,56 @@ +// packages/desktop/src/main/notifications.ts +import { Notification, type BrowserWindow } from "electron"; +import log from "./logger.js"; + +export interface NotificationOptions { + title: string; + body: string; + /** If set, clicking the notification focuses the window. */ + window?: BrowserWindow; +} + +export function showNotification(opts: NotificationOptions): void { + if (!Notification.isSupported()) { + log.warn("Notifications not supported on this platform"); + return; + } + + const notification = new Notification({ + title: opts.title, + body: opts.body, + silent: false, + }); + + if (opts.window) { + notification.on("click", () => { + opts.window!.show(); + opts.window!.focus(); + }); + } + + notification.show(); +} + +export function notifySessionComplete(window: BrowserWindow, sessionName: string, duration: string): void { + showNotification({ + title: "Session Complete", + body: `Agent finished "${sessionName}" in ${duration}`, + window, + }); +} + +export function notifyAgentNeedsInput(window: BrowserWindow, sessionName: string): void { + showNotification({ + title: "Agent Needs Input", + body: `Session "${sessionName}" is waiting for your response`, + window, + }); +} + +export function notifyServiceError(window: BrowserWindow, error: string): void { + showNotification({ + title: "Service Error", + body: error, + window, + }); +} From f3ba4d7f2c26bdc22479798a4461681896a4a675 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:33:17 -0400 Subject: [PATCH 09/20] feat(desktop): add system tray with health status --- packages/desktop/assets/icon.png | Bin 0 -> 432992 bytes packages/desktop/assets/tray-default.png | Bin 0 -> 21037 bytes packages/desktop/assets/tray-error.png | Bin 0 -> 21037 bytes packages/desktop/assets/tray-warning.png | Bin 0 -> 21037 bytes packages/desktop/src/main/tray.ts | 117 +++++++++++++++++++++++ 5 files changed, 117 insertions(+) create mode 100644 packages/desktop/assets/icon.png create mode 100644 packages/desktop/assets/tray-default.png create mode 100644 packages/desktop/assets/tray-error.png create mode 100644 packages/desktop/assets/tray-warning.png create mode 100644 packages/desktop/src/main/tray.ts diff --git a/packages/desktop/assets/icon.png b/packages/desktop/assets/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..65e3fd487f44221c828641c3904064223675025c GIT binary patch literal 432992 zcmXV11yoeu*Buy!9vHe|2&JS$nt=gCkd{Weq*EGZhyg(X1qo@CknT=N$w5%MTRNoU z!{7fqYt6cE&3o(J_wL#E+;jHb@2#f#GcZ0aJ^%m!KUY@J1^_T04lw}`?1$#-7H;E1 z1GQ4tRs#V19|Hi0Z~)-y;V;A%0N~9J0Q@lr03=cX04lfiCM~Il6WErj&lDco2fKtf zhdeZRZpwz900735|9+lP+YfyJaJ-(YDdPOWq$Z`odrduc_HakQa|OAVzB9WS-Ypcr zuI?8dZO>&G+_v_yw|fB?6hN(RN-YHv3NkuH1wxo&o*V{{~Si;_t1Q9_^!EGjOumRaIZuqIXK!MGs5>?4e$63&rYM7R)*beQ|l+w z>dgeb+jC-tHvG)!iWaP8;uto_{y0UYI~MA7p||Q$sL0P(6*-;aDAdp?KfBn3uCjl-ieCA2XBM_lWMZYnw~k!O%{SrOe%B z`@!waUb=+$nUnt&lSosL>c^Fse7i+CKVql>P)* z?P3D`GZm$`;AlUm47XD2s+}M_2_8SxZ5N#I3(MKh*!Y`F!?hs96#p8R?0&PQC`9tb zGu$jXQU(kA?6#a7rlD(%lygb&aG|w*=H=amT4c{Rmwf-B_IBs3*U33{YGiF_FDdJ^ zSm5F-6l(Zfhxf`gD`lO(;-6heT8aby8}vK!yL#+a=cpXU@d|Yja2vVjvzFucC_Q0t z%drT!RCFHQJ%CF3!7se54$tu0XxJE$B)I=GxkoDZ`3k30Ri2od)^}_o8kI@oYQHau z%H+QfekpQVa_J}Tm64OG1s@+CHU2=uOd@d-5@_Bts&7ODBzUkGS>Pasxy6GW$u74G z9e!#<`Qy+T&CE6OBs13GwImWbCuH7e88j?q;DAAjMg@Xu=>8OWg4 z|M%GG0WkPyH;-Qc?^~FUXGgRT1cVm|mw8<`iu4$)9o~(hPZ!_3agv1(wm8|V34LuE3qt)C0;fsX5(P~^M?HQ-<3Mot zYjpAZN=V1OzzXcC&dccUsLTw@EoLDKi&1fS{pTLG^Ryn?IQ^%>lQ(x;`nLlSPyW{x z$ozj^%+eaa!9(dlUn$Np2-0y7u;i&V45j{Eawb8-BCnBi3~iAef~ zbJ_HJ&JEIf55b}EyP{ zU#L1!AEGpJ{b6Dn+Vj6=w^BS0*KmaTp)v(nvEHP<;{DC=)T@Xn-qZ&&D)qo zf6$=7KZhTk_x{fTH)uxQU_-@bl{T2Pirb^j*VS%bI!ue{HXN;Bp-mkIN*u0{>%vs7&5{t9-au* zouq5}Qkt`U@Od-uZl)v2s^k0j?<=D{|NqFHDcJX}!lwzt={HKwgnLfBC6asmH7?KK z2@Ch12JdS9|5tcM79*n{xDiR5EI1o-zLi*H|V-S^VpPHdn|e-ENvY(L$q z`_LG9B6G@8+dT}6Kes)MlwzpMZ#Hr91#~S5yq&>n%b}Wj`6vhFaLvabzfS!h3^EJ| zp8xk^nk@Q@E)HvpObquKIcmdm2GvtC`YH80?}R5P)@7||t{z;F%y9)rF+Pp?R3>_G zKO=lPnbMwB5HlO!=7mI-tc3mZ5>UTg7x>%KFCMY2XY)nIY z^4sjT6XJ?s?R8;8bl#xmxVi zj~*O`Oqkm0?&#eTs{J)x3Up*&{O7^;RsCql)h12Ti4DA6a5gKrbqqbv0|wW(c3kLv zeLzglqsUtR+KP$>`^zB7>q>60v%oBxPUh)pkvzOORwQye1UYDk-QIHmf5w7@GUvi% zg1Ipcz%hb~y>aia|RTpQ$>K_Q`H|asJCgEOA z7T8pa41x|v6sp+0iaC&=@?~fAkTF{gN3}_{`=b(�Wq!7kwiNvyW!~D^` zjQvxYl+n}VX_SJc8wR7v6o9Tsx9R7~y|O!3((U5Ccy)e`tUA9}**45zng8@f48c1` zajb{Y;q@~g0GkjRoifnu^Ua^VBQwW zX!at{Vx6Glav_=;A8}v-D&!l3Z}nKSB1TGzH{UuYhQet z_7yN~7|dRdahvGWCu}a$j7BC2f5C{doyZl|Og&D-mWaxqz;aI)w}eIwuduoR8CN7| zfef!-_+_(#75yNe6lqofICW-@Mt1IFN8CgPJiX{39q_F~T+T@nP1D|UIDFE?JkUY{ zD>!ef_+QvrWcqI*J&Ieeubn@6DRf%J1a6())tH|*+0t$7kvf#$D|o_7>A}f{>rrO% zh#2F`Wx5*Fl^=Yr%hn$$*TyBg;@E*g5i0;ca$vg4n{elc1|{v0JR*$kbACR+YVK+& znQuazd2PbIN5*`o>MFh|8+vqzVf0W#i`RJ-Tc$aTF zqi(ii{zoIalGajie#$KJ0=4jVM3VVUMtxW@=G335f!Sj@@q#)%Q|!O-w0e8y0h)V` zj`)AP|A^)Z6!NZnxN{epaTATvC+ZD6$w3O53X?1X*i#fkAfFUy-J#b%CJhKZq6yvk z?B&E?QWiLWGDFrqXUeTdZ5hu@8d2BmZprO&Y?8<2t@8c!8j; zp~Le74zxx}`>8)Ae$nMsq`&;KK5}n)5_+Te^@Ax5OXZkj4H%M2QoBW|XFX0sdRNc2*^D6_96Y6-Ae)~v|J)O;-Qq+{& zP#Pn~w;(cgbAk&1{Ujh*#18!{!nC;u50b{6$U-blxDCw6n7R_i{BCu+!0|)Se)CUl7 zG>+$`d%)U`BdzE1g{hycD#;7sq-^YhX{bgN&lL8=QW(@>;un9{A(ljfJu@C34aHnB z?F}s)dhLR*I`CUK{C!Q;;yWYE?4LaxYi2doEubHj#KLNGLA89D_+^C0iV2t z2OrA;X2EyghGvD-;5-E}h3^_4S4G=)HPTN1irJ8pQ__kK!LXJ}8E@Va7aNzo{*gPH zZJy+6aY)j?pBd77FTJL5Qj1RQmb8etTHDHx@}ZY?~G9QX76bn_zDK|Jox%m=DuUaOIj;tV$;O`UGIXvi5aWG z{tL`|TZox?JA$ekgg#!Bo;qSpY~nmBDWLyar$SFBM9h`Mzes`*DV5W9On>a8z`O)YMAqm^OKwfSVOpz|#H*8Q5TLaokQcQSPAOZGmFGisNc z3n8O)ue5-1Y-{+QkJ-bdS;-Z+Jkd{IDim&(pldB?U#=wDzr#Ey!LPW3W$~=W!kTr9 z;B;FM)Q}~40m36CtN9`7k@<#vMdp%I$=5CGGdClM_Fa#oJP%I z`9Cw%0RUBnu2}y z=Ff06PWS9eFbUStTVLH8P(ahwCl4I4v+06wH0D`OY0IB+S$Z0O-Ab_Op0|A5Lj5e> z>-r^<9n4C3_?W{ddfgXBQ!K^P2CP&(`{f8bJ+rr{p;gF=VvK5Hmf{rV@g-Y(M6PgC z59{2{%?h-FdOD1Rhej?>XwX!jgvD#|+PTYdi=ClU%RQdKHun5RuVXtJ^QPfJUCbfP zA?_T6GWtt@`)#9aUrV1d!OU2=Pne_nwlrKJKDcogUmei@-IEOt22;sd`J@8 z(@C-0$0yKyaaC!O7iz?G{>C43Cg+{)d+2!i1KqC?dY>*pU^<;up1e?aX6M6&dN!u5Kp?VwY;wUeu~4n5Io zk{YhhYA13vmcpcJIL`+$|$Hz2Cv4&2wqCM z)p#WrgtIle1^gQTvmLNH2DpLsfAB)>`Z-@<;d6e4G^BHHvCm^bT-lmA&hn zISWsmo1F^e0(si(M520D=qe!-r30jYUun)x4RF}Oo^6Qw&z)ZJlQjt-Ncmmk^5K?WaxnXWbZ zA#n2b{a1zEY$x(xsG?5Od`StN+q=<{q~KPr9&}U}jwaNcmy@$s9>rW?w& zC*Q`IPWfyM&am^E#X5MF>}>-S8Hn&0taii#U=8{{}Bt!~S~B z99N1glg1e<=bELUb`+W&QKaw~c5$Tq@*3}Z469l#A+Gb=(_clQrgCOwvN#`(#}r!e zwm?@DS5Km3^50Lig>Kz!71>j6SxD>10xd*Nb$qeI9V1WVCFKGXLtyRT@6~W1d>&dO zc4}WCslfW7b*wgf*1J6uXSwYI_Ob`$l2c0Hn9{zW=KYv%2gX@7)9G*jpw`Fs3AOd7 zlX84NHMXC@h_^OR$vP-Sf4oOTgXthF%D4tS#3g{XWo}BO3H#(RSw-@^$5XdZGJ2e< zA1nlit9``E)x-!gDs?ClixgRv_=R3G!6=t9%GN~5bIHS5mzNBFJlIjSez&`zyRGR1Ns8G11vuZf_Ft2CT9+?`dIn|o?#R| z{TAjtim1|_&ff*u32o|(#C3`c>TYr24CwqZ@TQ%Lo3`5f)sedIwA6wz@yY>N6zX5? z|Gt!S3TLLgUKi7*G=+^3Fk4%-Jc{TsK`N(Ln-KyIG+{QG(sTXx-8!jWzv^PuYgXws3a1oi$C9TU*X{1}}fv zI^UCaufYcskU!lSOb@pjKvuLnQs3>|wx0*}wfr8f zU%#9^UX+SmS=Dg=n9yNC^aI`@M^wQyH7avt> zMJgt>`E&+CPvCt%b;O;iR_%I05UDg1joC>=K$T~HDN}=_WVI7dr`F(a<2`@_pL?1U zR?`HL5*6}3JS6XceoZPhO&g69+ZuTFdx(A6e3Z=0HW2sPRO-zWRwAP4gp4Y>j?}~w z7sVLpJ@;a`CVLdQ!u20~&CmW`SVvXbYELk=GJq}kD}q|8iM`Qm7oH6;N%>naygp9U z>$72+txHP|`;M7;%ZZ{hPvk$+gel^Gxonmd?F|+GY0Pus;sdjw>YQ^aNBh}MR1+hI zd#GV4&7|4w4KHoR;H;kKydAvKX84lh%{4c%ULIgJ`)g zm;1C0(jXwrWrTM_7Pj9ncPLHuBzhOIq_J$H1qyxNm6tmY^)Re?8%(Dlp>&e#$UFm` zk?>~^--#gW;)F=iQaXOf7l|;{77dgRm8*8ou<~ zy!l>!vglaWs)>EIxT9q%rf&*o#ox7MmqaodKGMhN6YteB=UlW@$PMfzgnnTA2y5X| z;wPo<LVDE5SVAm+12h&>3}rPym%%sW<1o;L?+w-G^*T>cB6iMWo|zx??Rj z!<>G=hOaup>SNG*E1aozw?LaL!n&q9kb_}GR<-yq4zcqox+w|d4nd!cH;wP(CKYi9 zq+OU}jWn^;W_sLoZ`ck-0IN3_2Vd0a-_-2k*g5K?_{Gu=9j`~}!2&@hzh8)*o*ng# zpLdi^M_y;W50f5c4B|R@EY@~nGI(RqKW%)Wyd)eR_iSN&5qn?^5ev2D%IGnISR}oD zCMOKhRbDYo!x(=)!n9n?A^ceTBLn=N#kk= z?Ks468?Z?;Gf*<%x~RJnzCsI7e{v@&%&K5KlEl3h9Is;&)hrhxx1YoSE6tbUYy-F= z9n)Ir6PXhH#m;aih6@GRM6hYq%Ey{^xe5bZYk%96N2oA;x)$~p>*jm!)3XPf6%Fv* zjLdH3efHKH;>+*F)&vQ(3VW(#8kXCIeD<9G*SUg{Y;OV1_{OiwDAn2idc9Sfi?Y$x}uoSB7rn}^c%S#-KD~&y4zSq0; zD|`N{_kYBJtqjP>z_xBl#uhlCJ$xKv=>wIt@@zVaXlv50_kNwYk%SZjTSLl8P zj%Z5pz=r_0GybXMwcFC~FT`1D;d?wpbG{p|r>2+OmgXeH>XzrMF0)|!x)ERCI?!W8 zokBaQLXrXJ!`iCq4w6OsEiq!l6UJ`Zx3kvoilT8HE3skmi%@NsO_$xnh~$O5Q+9V zeqiUYsv-lGMsQlcrSt9p$kr6{ktbZw^hF3%LXrvtnqZ{?+@_yAgoJ~N^@^)vvb7qG zJh{BWi-fp0l4bCopOD3|5dw|vt|v#hAVFGY&z~M96FI-jhc6S}OD@ZEkRsn(5MRJ^ zFg_$fnpjPY9f_BjKe&u#LbgeQ1*+&U*~5f@Rvoef`eQ!yf$V`ARNlzk)`&QA@9>WI z$Z!OcJaL3kgabm_`<1Z7_ z)sx}-_vf_`*8O!3{BP8Y=MY5GSSKm^s$^|P_iQ!dInkt0`Viz>f^vf-Q zxLAH*YpXp&UJ-i|nq18DXZFyHxY17a`!^C@q^AxEGhkaG6-b|BRjNBt%*y@xMP7?J zwIfzmzlgU_^-8wk963qpne4;n8{kXTn;x3dXC-L)Cv1oLoaLO?&17?H-5xjA{R}gJ z$8DtgsZJKA4|jn}0Ip?S<6dkQbi;IXFxF`4)oOHg7O1bUu4rHwMtqyo58)W%?&sXa zV_%R>NcJP%E%M!3*7;(t`m-%%oX6Z}hD1b~Nn6dmO)Lfbv;8Oc|CP>Yym#Y>s}B)ETxlB4yIZW;YQw)}BL@N0>r0e71>ziya0 z{43+X=V?xTb2DCMUmE1Qs@QVJWh781co%9vZ}0RHvHQ&@(OGVTu5l^1ydgspiIf^* zg|U8)dJGf%!FKBroVMt|H@;|9T zUh?Z`{iC zg<3@$Wwb$fDEy?!!*^Z8MNS@fbv}(7mKettU98!RA^U57avEf%?ivb|)Yu=oq^^?X zYvr$WofoE1fad9hy~1zdb`0pbu4X6TKfw{5#Sj(Q&g zR|*lvPR2t?&;X@6XLEW8UuG7xcU1O+n>6P3lX)nasZMn4G)jW<6ZMGTMF@8f>h8H9 zCst5g2}>lhx^7NW89D;Rh z{HHzQQ_>q)mY+mzP8868f!fEFOjc*}PnwAYLhxTMQZVz84}*trlS7w^bCOwSp*0-G zT3#68N#Vay!iVz*I)TPHhjpPDpfB0kA#$d7K1-hD!zZnvoa!7<=iBTaM>!s1YhphN zeMEzb*Q&#k4eEpz9jcd05&vS~(qv85Q&f<0+d@d;UM!Scv-blhXsWlus2FhOdMQ^O z))Wu-*MNY?j{%y*89Fc$rEu8eP=j~m0AkeZ9Dr8$4mMVw~lVxlVo^pLg_{Z_9d zt#INgJIZH)abw3k@jB~lj}e9Px<$yJ274u5pliZD(LRC0Ai z+Z|ohrPyQMeD((a21a)<;2B*X)tQOgd-wF(%TD7Fkq&o??%O4X?I}X{7%2^j&9H*d z>U?K$j@KpQWmtZbZ=IibT9L6n{_q%iSGou z;0Dq8>4gv^s>_osA}*ALZ3Lnga=#S*xFlzbS?n$s!#W!h^~#-gam%OCa;tNB3mldF zQ#yn3kUl+XtYJ5M*s@)!uUoG!7p5Kty%Ns@F>?2D*W_R;ZPl2{%?U!Y&t}m&so4|4mO-9kEAaM zHf81|1yT?f>yN8T_w82BN0!X#Fh1``;lMfbS?nr$ft6QKiVXRa4@Nil_V!z_$EntU zEI~DOkW#mvRbNlM`JX65t?6Ok9@<{Y zlV$I?WdjBW6(;07owK!f`r2L5!-+xktfFR9ctQBlr#Hfc zCugCFt4rHa?mE2pOYs~YPp@c0%Yam&w&u~1Aa|!uuQ9t4>}#tF)p|~0=zT>0ZM^!=>k$B%>BJ<;D0@6|XoFeyzxAIyGzpUEFHyUVC9Q z&i znu$$bnaH`pnt+JOH^HbOef8;62gQJ~isF)grG5}t!N=x<2dk#(5Ts9l9`hOCc@#kN zCQTb7!|B~b=m5lJsP+#%uAXhSG}f_&$;z8xUP1e#YYw8uQT8k;bJ~P;wk6QzlTkpe zg7Y85am8`&F>QmX2amUNSjt}I@amP^cRRfIWQ-9PVR&I=Nnw3EjbkSeF#?7#hQSW+ z(i70^D~M#D^ulsz_&0%u-*R)W7P?0MF5yp~baO*e$rtF~bxf0Ok5|onuZs2u~BK-EB_6bTeww!JOSk zd$mdk@7sTRnkJ39DoCO(m=a*Bq{n=~2xAhk ztu>D=(jJ%nNXrV4TzfN+ktIYOolpLTiwh@*F{dV;;WWwrRjWi)Y%W;_a?&rM9+6Z- zSt<~{ZHRq$pXv3*sQsAUP>@9G)|W+?eBu**Vlps|FzoW_DEhnbO_)dh4au6Ov(Kq# z{9bN3iWqaXR-?AIBY0py1g5#4$bC8O*5_2*cj-u5$=UM(NTd}rh;VRvsRFF$UjLK; zO`2|&AVQ{mRj;DLILfW}#q1(k+O$iyWFeL9f95tujOlY+#Y(|4ZeLu6`8n5f*GI}M zW>Kka1dS82&>{*XMMda?MU2vylPujuz$Z!yz8X04FIA21U+Gk7w zXREe%(l}*?Wpe5iCIYbq&ScOt=}|`_Fez8}+#h_oz@C&%lZ?*RVHw>@IcpbR8*{33 z8jmy7JHd+W)Ops}5tOcX-LA|WNVL7R{codad}cy(=Q+?m%b|KrM$=@#o&@s)ZyPx= zfOoghyb*NALlsp+@L2?y^iuS+)gM(RI16^@Qh8@ZK~_`I5MGgQOb`>3vZ&X>=N*=F zJH!xjR^{)CDn!WV6=PySKS*39f6y2f%n|oP@1ZC(u`vezGUcrow}8~} z&2kif1WKgaix%2y6wcQ9m*SVhc2C?zR!Gzu*lm)=ka4N%_?k8($i-%5UWi`@!*0nB8qXE%9OaOpe34H z?j5=72@!w1+zLtX^xcS&$-N)Ff+p>Rop_Nf{=&QzX%R42#II&~)8uY3)S|FJi)Kx2 zEb;JV{4@D;Y<$FRRj3KESfRoz7<1;!laj^BN1gnSyoEr}?|5f`*OrL}MBmrlnk2%e zT+B8D30OrsTr&$!PV9>DB~l>`aqPQs@?u$ZPR)onw(jzdipQI|IXM_+)ylk>j30;v z0Z~*(YzY56{{jiX-0=LUpA6!{1+SPCpLzS!SK8-rW*6_k^NaJ2+Nr;lJ4SBFKI&Bm z5h-1n>#;@g4Nq(fis{$_X+1msiZ%F8C3JT|?w{QFNYvaf+wZm0cWCKQPVDk-hA*L=|`yRPq_-okRIln z*0mE4=B>WJ0eM6Yu=fBl?ANM<_+&a9G z?iWuEFjluYG~4Dr-3u)wm8O};aY{;?!hJ_YmP&ZKM(fUF-W8m~J3$$O0YcDq3q-G3 zEnS9Fbv2q74@lg~m_HJAIPn~7BVZj`2@+rnJ&hQ}k^!ZXX3~Eq>UMkN1L*mNaWDBU z3Mo%{f*1Aa?3$h{s&_6G`k2Y*tCS$M)`as9Z)r zMwSd?*AizInM3#?F7(DUxKB_sp!l4dIIK8s2Y#L$&o9`Sgr@&krb@(S20kKNrDKx< zy37Zm|4KB-cwFthiAvkq+YAJgKI@TLH^s!`>we+$8`Ss9!SIrj{1@+wC%aeyt&tisSu(O{p6GlW6;Db;kgFx6&v8tgUck!3^ilj_`5feF@w+7aY&**F=$F-mil(gEXe$cEj;vYM5F3IYCBHb-(-)vm*|9;k8$dJG)d*Lk5=>Nz* z#ID*wqWUHqjMO1_@;mUrLPn}O*AF;l_F!Lc_aGn zP?W>Jy22%g!Q-*5ooy?DIEAN@%{joV$u<1|FG}xi(HL~8E0Xvk<@pN?qj9|&5vKa} z{7ZK8z-JoS@q|TjLH-nOaW-CSKuxQuVs@(u+(W>oX4K|)#ru~kS|n>P=F4jVsWewC zZe)k31>I&+j>MC71Hxx=nAsm+7{bh-CZ9iI#f#IKg}Pau!PnBzADTFq|!pogD*!2nT*0V=)nd@n;}28L*d|Q^Ea1% z*Pd{y&y`_FhDWjWsj&!-f8?vdKVfB$Y&>bsEtUPaepyxy(2{V^RekNXqY5Dvm%vC~ zB$xuU#v%S70t%|%W%t&kjoIve!O<+x2p>v7i=q$r@Zs6U)1taNzBxw;-dDPQgez3+ zrdb#G;eD@Vj(FDEUS3#KJY75GzIa?gi9d7M7tV-WV(;ww5RhY^anP0fBR&8=QnSkq zb$qRtTEd`NNdAH=5IdLnS@W|Q;IlPmB22O#uOm+MN4=Wwf~S0x(aCE)d-tT`kElYc zL7rbY&1bvudF+4VD=!7|O8?^xj!7CY7~Y0{s5T>+Vr}(c?q{#b_%Mnn$i?|WAUE=9 zy#}M>aZp+dS-)LbU}Q)sDEo`WSMrw_EncKSh{w6PzQ6`0!%`_+%kahuTL~Maol}+oMV6{(iuAGgB{nX zfaD+W?nVHzs+ExKOQ}_XPS;(73>57)?UbV=8 z&QAOS+I7sFybr&Ocr>{vZ>i+WWd2)#NUxAuQTXXhMct;Lx!{vcTFb=1xvayQU?%?>rrCNTIU23uZdqK zwqW*Kv1kB8Au`a2SwBVvwWH7!3@?c27**kSUM+@xs@rZ!X!CLb@m6Ui0iAso8upE7 zjHE{2NAA>$mP-WoyNg>1P>UAFnToen{GfVJzp0%o2D!(L6vvY4223-FF~@n*J2jpe z7}ItSMb-BGj!1mPIr{Yu@H{NRk*ytDfVex5`h>EQ^S z4+MVQ4}PId>j}){hu^vi4+JiAaR|)i>35F`pB|C1;a^Gm*X`nX5Svbuk=FUyiBZX& z_<37T@1d;}n(h8fAVek82*3R$`%0cq{&*3z9Oo5RMeJe5IY%c&XgGXweqk)v30n+B zpFmo;y?lHn$mg_{xTgpWvurX)d?~6Ds!%pQSof`Wg24=@4*t=M#4D@G{Ba~w`-9GvlO|WZ zh6V)qBWWGE8C6BC@JPxYrbz0B`DS+t`Q+t_IFlh%pS6(4gF(O&)X#(fWiKM1UBE&j zq6cQP!8t`KxL1~3oN>r>wU1N89^zcyNZR~PrWoOKaH&XS#8{gqj%Xzk+`)6KxdKCljP7{8;}hU++oJe z&k_i}h`pFc%Ec!ndTP{x1-T2(H8fB+amPFB1W`n>r|-P5jG~fiFc&OJsByl=JLp-| zS6uMi2+C(e+<@#_%9tJ`z6gK&bZmDrEm6z_ya7BYk#=_i6dUq^8{rsLMX{xj7_?zv zVNQonfxMiu$M?W^Ge*7@9%(1{hTmK8%@~G3gbGja$UI*h8;-J^Hddi67{l?s#Zdq* z*<;KXHXqXg#~6N0=LrAgtCV9xU+D!&E7S1AXF57Mt`QSg-^9N?l^=RvX=T-iY<}+< zYlXu$@y>b21n@0vwf#&q@}jtf=ov-)W^Q=Z@}X*9S{4_MDo(kd)nxPGUWa#VSmg3j zl8%E577K=RyeTk|XoZ`EU;+P*jM52T@^7wL-15qiJIyx>2DzJ2~^#3zlmLi<5l zd?#a&Q2ihwN8HbqX{3( z7U|;a^S6qZ)|awKN~mSP5#t0+RH6~@QfVT8M#|UqH$APExL`Wg|0^k{KDL;AfMFJ` z7zp;tPT(MluQ`)__|QisxK8-pkclj6w!A?JM%|TRaO1NV=tO8sh0ztyCpzc6vA2?O zZSZc$Oj0%tNX4aWZ*kQAwV|$qbIIlEhcR-{UQX4GO;SSAHN1N#;p~xLwpYy04?pYW zzmLCt{?;c{a@f0mhdJtcK(bqaPJ5=C_(TDEc`G(AP3J_Qz);GaUYu}e+8byv=6*{R zp!Yr0uefOUZDfYxGa|c8kB*#0R=Qdj70&X{F}OG%L=CR z3Tc^+rMpG64z7&N=XC62Q$L(rm~;;6C5C(L>O%A@K;A&|!Y4hj_KLR8*E)<*lhNi( zN{G;O#uf*NQ?`fQS0*%(7SAW(4AIDZINL{$Y&F-b3~hwDJwze-MhV- z6{J4{cg71pva-eb?Jj@SrGaDTk301dHOezZKbxWHc_H6+!%CViN$$n^sS~ch-FtJ) zkWy1EV7D>0eF&DcrmztmnF7#Eer-=%z`$SNEY!(HylMQcS&V0yl+q=&gzX=*KwS$e zF&m9ZHKW~EoT|iNf7=P7XQd>rFiB*kS(6mb#ji*bCPf6&Pa$q5{^bA>QkbL)coGABI3Ztd4^?4@u*G^83y=tuls9FlTnVK{1Hh+F&5|3fs5= zQSQ^YA9&d<%&wcxkb{9X4{{DTb%z*acwP130LDMDLX*E;ON=-kx_)^=r z(0DbeHgU4Qh&MRV;ib`YI>Jig-e5{ekksemGI->gW?+a9ZK6a+)4}T7 zsWy-q{q$!VI6gHk`QVzQYGd;~{zO|^n`2?So;mmz*`$J*VE0nSi6#O_KJ;+poAjtIo3ip=Py{W{3|ZY z-FRSP&okU`omd-^!mvEv<}g7`m1&@pj9=Ou&d9J4@D*s*S6XcZv+vgx+M=;9YkEEdmhWT4sH`AFgi9SlLeT& znOLr%6V(RIgs7vNICZ;~;=@uNWrlBg574ntgpNcwD9z_9Kxw}WL28*jG{5Dy z5ZPxd^YcDDmMi%N$E^GO~i z=MDW4I<|TZ;XCfu?G_=WNQq8-fsc5J84l=)mb&O;MabiG0vJ~<#Br6`GrZiq+@y8` zNj^&E?W#RT)MVJm@Ffr)4XUd}(xio_k0h04lquSy|{8udMpl7iq6@4W;XEc^;uS z_v?37Ec2$8%pN}-B+CwAFHedvFE0u%N)Nx(;~L>;%SV_I7o+ zo?tuFCw!VDE7!X<=iDaM?~r0f?MoR*3}VDB4Gjf?n8@EndeYd<+sTHORHk0i5HL@P zZxL=_NKTKuF_$9iR)8YAPlA(ULUPVDdVPIzZI!Rp$Ft2ixO8aOs%vs7{|}i!X1_4Q z*x9BrSrmYX$nh)&wVj+LMZ?D2XpxeXi}^hUZ3Y{T@?G6JFwugTew0TPG-Hjzp^u#&PQ0Y8eeA_>SbQviw$+v3pvh#Bf1Hd6z_=kHfg zKx*dgl6!2$D*@GTbctfefZYtWE)Ml~n751XFWzBynyCU!Wv0vrI&+$ApcU!l0rkkC z5QOPaIe)xvURj#Y!@Rys6L*QrK|jDLrh@*S_(%)_Js|cm9>Pzl-ze!2aVrVR6A*q! z=^{P^-+cQb^*RV`RikQI@a?g+Rzl#v)i%gh0YZv;R*8YYO}3Afkq~`LIUufq=q+Nn zk_7r4VlK}D3#meBpt=!RAUElRpB=|k}BcdvH!hlKZHM!8NvTBoFg-uEGXxL0#* zfZ+T7+Y8&lh7sE`_Fo5IbX(@x_B#B?&a{(3C`j;a2sZ_#v9dsv0kKlND|!PFGo|L@ z<^r{ePM9mCHy<=~idkgP_d<#Dt;hfii$4Hs(z3AlA7UE*C71OkNo@^%_<*5Gw0gk?}B027aN9KO#^tms7FPR1L;70;4pD`Kzzp{)`MC~ zUo6Xjy@|eG9|rE6Xm|Zy@Z?92X=xC9E;1w92E0uoeYK?!Ga}kjn+onw^eXLcaNMo+ z)vJQz3;i?w77+7gPhJ7VCF{rsK=kGiXMqDG;01ZaxIW7%Pcrb1Xe6ot>nKek$O1EE z;2a*DKrSxq{NJ5Q4l|eEX+|(O&D#z$*T4Ahf7Xm1H5~vU)1V5OH35om2hE)R|0^DI zoHAwvMxt3AzBt5xklZPc0XK1&vmk1bhYzS>s%|(G^nqfwcnb6eVij*dw5b>;DnMwb z8d1tX_)2x75`@C{?X_)F!GF2Us~&)YpktSpBFNwr}7{_XM1CPmV90jiC1R4BXJHc9W{k-vG^@_XP0*^};|s%km4 z8pIDx$Vw;+Wk;5~r`#$?nx5P{c|LenyN|n;LgL)m8Ll9dUY~Sj%zjANMn2lS|8PtpGngzw@3`Kv7blN2Dw$eU$a03W(w2UeSh&-63#+sG4Xk zL%%dr0$%yS(B1ErINxPD0)kjrSp3&mlaYnRf5ETp^qVv{Z@*%O_IEvLsJPZV;Nsos zFV2(?5=H~Pr@lnC1Mz@3$Bj_qo^n?u4u;;9E`O(fE$BX{&O0D1{&fC*DE?$&gqS}@Tj~H4s6#~%JDANXQ18<}lnOX!Y3=nm@Ybe@JQJpgUT*R-q8h$awX1!_HQf#OvYtzIfAg;XY-qc&V+SU1i|7VIig$SmL?Lg8M?oZrk9Yw@Ej|?^fmmEPK-?~xQ4f?= zLKE9T>=SMdfbx+zEtUfh(T*md+$DYzGeF4~rNtQ#b(tyN1RfWiXbz$@6L|&1Dltg( z1?o|TWDsqrOnIOz@pyquiU@!_MJ)9R#E0PwWM1V{}naE|gzw@rO`cT<{o2ISO1Z z+sn3~_!WoZg}D0htO-pg$Z-_QH0&yJZeQ(HQDTT9pxfB3r0B@p>ulkyo*Mn zYtdXFG9Yk`p_9#Z)EhS&dh$St^UtrpEQf%F#c#)&JS;4J2miU4U)9!zK0nXU+qxKP z-(BMPi!Zd_3`Lfm<>PV==yv(I3_?oXxYO>>py$(VYt*{MA=c#PSQZgUNYzWcPk^IO> zV49f8Y@jPwi>tAU_5E@D`>Oa;L@mmL>`gbC0%wenceRU5kbS^eOLOVz5OaIvh;|Po zTo-B^X$MKmLenGLA%1=MaAYoc%0)J7UT}P`Pm(u+SR${MFM_CR7(Vh*+EN#ILo^lD zK>k2ElKHs?K=FI7m7XfS56idpEg(n9M%)NmCw-{C6!hbAtF(bU#oas)`YwH))Ipy_E7=#ADA%$b zWE#&i4&>$XEjbZ@eDZ;KbfUl!vd9ApD4+mHK%xVcaAOC`o2djbX3C1!>@u*QAR4fU z9Q?p;Gsk`pMT9^ez)u)BZdUuxFd}g%GDD4Z^R;lB4v=IsGNU{$Y#^%R!2#4Uiv-p; zwJmWtfh$PBg%P@}0X}nQ{+t;kxE#c8@r<|+l)9p&5THCS_OJlNP_aYI1+}d5y?7LqNt_caK#5Umib7D@i!Q-8*XFUf%bTMin6gvtc6U7eE4T3+~1}P6hL0QKdTLR?j&IEf1aw|F&dma=V zbR4r)gFr)dwmJ^9=anag6XY8-p&E#(e9v~^4Y`he7{w}sSj7wfXo?*Ir#Zzb;7Zw1 zwg<(h+7%DPZHR9he?OEvTYhc%+K}>QN|)40;CbDBy=yb1Tp$0byDg**NLn0I4q|++ zSJmerb7e-Ij4JT;D=YK1-VU=^R&hr&I5h0^r+K45_K*_^gEC5~CFb+9gYV*;>xyGx z+`qhg-DE?DwKw$p2Ie1vC62cu11v0l1J)#AVeudM&msOI#?Y(1h7LD9)J?{e80O*& z@mEn1AQ#Ft@(ActWixpkVy3#DwXcGXYnv>s^cD1Tc5iptlhCY1gHknX084B=T`7>c zI=@1o7o2OIy|?IgD2)1-hVr4{f&4c4z2Wqv({oO@gv_jrZW(Tf+#IeSE(c5!)0hEt zr>D3U!{EPoLnQwSepy^^tJ#PC7I76#LB2^7s)F*Vyq?#Rk{uiX9+mUt_n<#Wd9DC?k1Q=aftIBAlb?e2 zxtyECjtS?d2%Yv*i#z2f2}af}ppRo#kkVc9oL* zA=+Ic?+1MjcQFMxVH(s4hM}%kk}t@Gp#3PT@GR)pGK!_3-!0#j--CRYiTnt1H}lvA zvabAz!yrd;jBFs!FxlqL@NmZnq$B}sIrK8SwYPAd>&#lxZtC^LDCD?lA4<}d)% zC|krZpn-_N2?UIgWpOWe(FSa@L{xkT>RZCcSg=hM5%B@=8r3KT%1!j6C8*oPDxLsk zg!n@A2Qi8&Bmv{7K`MytG^ZlagIMgqPNS$G8Kz4ri3H+-Q`m5Vm@Wp1ejtwWGJ`-| zD^`d}pu8aN7j-~cFAzIH?W>#+Z-d%WbP!HZQRXT4fpSE|a2Uio<2bQZJR$A^@u->N zP#iImK_PyShsYwApHmo$L$^zqmnaeipO1+vGuX4>zCg1(Ma`_&K_X&bIQ3tC;#Q0xNY%@l)g`HGGF+$Pa` zzE~l@d_)%i6#{_*oZ=)WfDW>?YzazV^&#akNH~*lcjDVnu2lJG`THRGRLbiqTfkf0 z{kCfor0z@D;SrG5DEXzBli*%p>ml!jV~?Hq_|yvcqW+TIo18Ge{;INjzl5_(a@zZX zpu8-ix>!v zH`F*F4c!NI4Y@MvLf z(Uov|+37W>xMWpHqK*a=B5g}w`)0PoY0_S&c5Xru3z&lr8~ zR9q0quQm zl@lN`Kz~7|LAbPhK*oSRM2=$x=yhd#MnM#rCHsO_TDFuUK&~)$@MSVTupi`dX0ZX} z3OS37Ae*y>BR~#?M1X*)Ib@nS^XJS^_e=snE?ESDTyh9uL>7dBFd?Y{rEv=dBSc>X zPLV5(zuSZg#1exYNF)&_kVrC4Ac0ieKr*HA0BNRriN^sr@S=hkMlDK#XfOJ38HlFb zL^BX==*?w7ePVEeaz+dn*MZF^5|{zD4@6Lm1JQu%X#)27$`xW2I9iFhLIJg$*uzU; zA1W>rOTaNqSs`LTT_l!?M?qaK6g~l4dvQ>_0-_XMsSV;vZlDp+2n7u|Z5YY~u;T=D z(kKJsfEXbj1JO!+&4-{qDee%Y+W1 zrua;Z1Tl(h=*0O*6nT<73V|bJlgH0B42mNPif5PxX19dr#KH-MPK z5;g-P04Tl1T2T?iZQ=@1n~Sw}K%uFzhG-QGowLi(=RY;{;6o+Ovzv~9$gf?% z!s1fG`mwjL_!msWzc?qq#Dr0EwxO>-Z|L=>3{`yQ0mbV5tDndJ3_CUykeRZHd<|qz zc?VBH<(#xVaV_E230Gw|Yz)1wy*#JcEs)YawL_`pP_QoWP82x3IBRdA4|4A=_%Qek z6uEpK_y)td1!vZsxgO3ua%TFO>miUHnBjjDs80hL01xx17{bqv2aDg!FP&Cq?me%I zW>g2+nd@i;!Xw{fAvo{XZ_%qj+^gYmbQPrT58M(y3n|YBUkEFZ&?hu4G8~+sW(a<9NPestx?YuJ;z3j)iFhF02(^}7Iz-KO^gZH%6xKM2}0a*W&oa+dWzf!k(>3WWh#Wm%d2Dn!msI_Wf4Tz z$SU$#h@6vCX#hHMsGJLO6d$t^^xNbcECHsniF3d{zTq^mTh5oqL2h9YXMjaK#%^GY zY|W1#56aItjZwv40e(Q>0A51F3-Tjuc!86m7ga#a5PRqfB1g0m_XE$02YDH2rMw_U zgLp!`!YB}9l|kYq;6u@g!6052Lfi^Cd6+t&-^iWp1=&mM;zsoZqE6GLjU65_0oq51%US|i0n`JKf zz*8s$fO`=H0K1VAAl#xhUZ6kU(;Da_X3zv^&z)2PQA>0a<$#9VKqa6N%}4>!LEJ@4 zP`=|idVsiwzO(@QFr|f93bqUpC#HdYhqy+p1Ls?cOSA&}X3CPXeVDo%%J(gQLxl|x=Z~)u?}WI|y-Qr(q3rPFS7Kg=l*;it+zTLFF;J(dA*}vj zNM7DNX{3hNJBws~u3>NY(kvyLY~1=rf-g z`t@e>4{@fN8#VZ?6afnh>qp(<5~oCn|M>~R)Q=76o@eODCk?G%aw@$*HQRq6#RmUW zxm4~2eTr-(4?;qYcad`e^r+rud5vRmd;gw;TfPQ07FF9-c?|^b(v~Qr;p~{~v4w9z z=FZ$~|6VAX|{YuoiFLA=3Q_JQn9Pnv@qB^rxrz!@_aym$sF&PlIohUQl{cJO6!Zo5kkm7_u1 zF4sy8v^jcJITWHN^#ytwM0I_oUIVmD{Yp6obidpo?I3%|H{?e^Y4XSh;>_ZLBgr5D z`Z^wA4n!-^CcCK@HnaikV=a=zh`G8l1Pp^|ZYOwk58k>UUtj#nDMg0cSn$HrqsS zZ;rdyb{JgYxCZtgLD_2`qf7*Kk@}9P3%2Htfyx@N-{%;pR0Z3^&ST1TV4vkYuJi!g zOOD6Y>R@v_W{aa>yUIRXc>%-*Wq{ZPMLqlnqW6O@-T$FB0ZPB0vfEh&WLf=6c`Inm zwHk6MXm!J%>TMx1DZEC{h3IXemilstJRM5Wzl7+V@V(l4h@|^gLyFoZ!B$7< ztz?5bP4y`AL7gI=5iLP<6W@yQAa128b@(~eU@sZJa1az5b}?ou$F&?K9at(C$qi@D7gKMDtp*8idB)gJL3XFC+{{E+u>Sj)%`d{I+LGMu5{{ia7gMkV z#2K-c$slZEm3SNo|9`0<|70!@VVN_|&{0nqI`&ILeLc(rtfGMy7Fa*t7MCa`4FBTX zd@~r*)7a35(hPm7x1q`Rlo;lpAL3uUzaAlq1ig+vS=IwvJvCPhgXUdp-%#ct+;@Mk z_AS4GHa9l=v0e-)?>S>Ub0K3=ZU^6LI9oB>RdgDPZuhSUy$jjHvU0PQ!O3GMPM>%J z^4`l$&OHfw8`(gw4a{Ys_zH+6_Pl@o;@P42BQaj3u(@OWu4qVQkj>~#J5cVBgZUU- zPie!n*CDB4@QKKLNL%Nx9P&cymf-E-Oo$0YT+x?6ovlA7bAb%pIDpH=b)qH6Z>c~k zKUdASnKc2-oO{uLGNb~2qu;x1AV>Ji*&6hQ@?{o+Oy?uk0pH1osIQ0=hfh> z=UHhR53y^Khd8Q0Ou3{ahYQqi98;7N;0U_x%5-qw=^bEO2{yZ9k#Y)HA(FWbl#xol zm&cECXrPQXTr>G(-LuP(q# z5_TY#1RTH-4p0R0L0y-(fWBStAj^S%wYG;IAa(hTd>{1F+G!bpU|C;%?GXrh0&hf* zL$qUfxx5?#Z3;h$42Oc%nVmyv5L{7|5Ost9o7`%Vo{%>!Jw6zK;P8Sokx#(?X712% z6ats!$40Utssw-3YJm23FrqaE`Cjx#c?1|KZHxn2;q+< zctvys(Mrq{?}BJZ8A^fNZ#o8!kV8HYG`^STS9oR@0WnQ}FSq~f*wYca#rqIQv3;dX zfb1`v6CJlhdV9}dX8~lkcTaXCLD69Q7WE#`GDJ6V7Q~zU#6Dn#{Elrv8T^F!xk#wR zZ=<+q?HJyXZvzn`M8NyJcat{*%5^JWtHLW#dU4wLGBFS{!TYRRh1App-BSk2ZcJGg zI}cn{)H(VRIQaeH&yM{FQ@1T_xo#GGy=QIG!SA5pN&l_kd{738J)$Ov&Z4m>&&8H1 zP@;HX)NHpr`(;C)8)@kAloIDDrX%3uc_l0?egoEzwZ$dHf6nbM|GuHa7aH2v4EeXm zn+Fs}26*_V<1})=WpDYi{2KIba=J`}3e{5=#O{TDhr4~ys5;!(>&k~)w1y;4%BLy& zAh&JN?U8nH`fOI)g7+aWt8hjz0QrLo9w=A{r-qz(_(UFL+?4S}`ap<&7nu-!7g#0M ziH$&Is!$oLTK}(OygJ37)Fnp0dRb50N=FdW_>OJh930KmcR_NE&{N@skhayoD6|4f zy&v#|=R-`jh(G!S*aqq2qy+gn)hP?IyXYaB1G`BghM)V~7w6*Fq!fuDs*yq>$mwik z7s&3?D_cNxj$TE70-`;&+x49gxlQk{?}z9;dPu(!^m6)1nFM^wLY4yUh&4mo&*2BH zp}dOsA$+-fN~S>YVSTSaQb^wPhMzPm~n69bEoTVUUdWz=Q z2#L0GUESLu?&H#S*K&x{Q+hd9LVWvF=>(i7+_Tgs;0eV&XL}UXN9~)G4?t7ncrnINiC1rNxdc#i|X7RGV_*df1>XMqoRlARz2$#$#&mNJ#&KnOn?P(Ti0AX}yr z1ewD*LO_(r|6+M6vcx93Lw;gmrN}K%m{z1jKZgn(%CvM>1bwbN#0UTVb&4H}BHnZq zB#Sb*fCN%-0B+O4P>m)e0B?z!3w^X+GF7Bl~*nD4di{3{#LL#6m7|_5t<9xx1Ed+ zTn$AvvzLTkfWmX>B3KtfuNI7sJ^+!BPl?t8y=(Lx{bAq=eJq1Pd@ROO6PPL-TnFM> zaaeQ%#`6r#KzU9)%;jKfCaQ`r!EwFvm2iN&k@Bn<2HrC25@i~=HD!=^0vsXbn5Yc4 zgy&es}{J2^upKNl%1CYc~%5O2!0avz9=e8VQtdx=Hj1qj63zELJYc4_B9 z#|SuE+uO@|1!Nv_uX8j6UuWBsY7Nkjh!bKmh#y$MI^cP^iGzRxt;8>x#f1<+h!7#* z9&VR?L9`K{FHY(joQMW}Fh#lDr+Lh@ZH;gr@8JK5XIH3rJGPHq!(C6peWc+}ei zqO(Gcd}Cns3mca0yb3qufr06M&}Zro%I=`Nt<(_<`MHb7#lZzq1U8tF z0YlAo+^VNaoL78&$chZGxD>E{lr1g^{&Q}Bt3HN~T5f2&j1s5+^Q-umDB`E>*6)-G zcpi7|SJ%N+j^lJC;1?s(A`@8C+AUH%jryPPaPiK8qSOgj0Zh(f6@=jX!QO%Pz$?7Y8^Bd`JKvtq@~{6pe(45DH`~2kEsT)+ zCB{yCadEu_PpD7iI!N2+pBMTL(hmF6LJo*46Rr_C4mOW|quc?^r7CG4yNYW>3*dlR zrM?)mot$Vu8B%~Gqu;%}LVh4;f%cl5AP+!vsyLmCb}M*JBpq>-hlG9Q zba!1yY*{YFQw~zPR{X+K00}G7hPi4%+>faq$LHXAI%b=_6*wMsFIJ9#(oFqcoC4)l zWrG+Ca)!L0O~41Tn_LNUEDx{+=qXcK1gw|ek`DODCk!&593p@$(I)P1#-HW@_@keP zhgfVtv4f$ssDuZYz(%@&7%je|18|%8SX>6;d9j%*L3Wpyu>$m&T76jxqH1`e-WL3^ zg%hJ6fp2*Jp>Pm#^3M2zw?b~qGgk%ff$SGgEb;Gwya&!~2vmTgu^AtPzJ-v#U{=Hp zTDMR?eKz3IRoM>2X0ei{z&KHwn?dvy`$Sg|8@Zh(pvH+kybO+jGC>5u{eUu3c^$kP z)pTVAc&ez&#B^}Jpx8xou;mGtm;hoA4JiezB@aK)himByN}_U^5Mc8tS1QNAj=Dv? z9_$O1X-Wf7>nJ~or$96lbHv*qQi;I>ayzHVz^KJxg!UVs-Z;WUL5wsV1K;p98$h>- zo#K7)4Y&1G6Cv|+_aR4nIMd9#*fk2WUUH?`zk=Wd+c5PBkX^Zk79jS^&sYhx=L|W& zd@KLz&(hzL;`#a<=QxK^Oz<*LH`vbF3ZT^J(#=Xe1{KOxtXgR*#4nEfHtr!vcq(>= zt1*Wr;gu;M~_a!uKpF4aGcB3dAGg z2GJP9A@I+iuP+dxd1`{8FPYr~rkX_sqsz<#%{ z{Goq6&(JCpN(}SQ5AiSF=}(ru&Twx{gma-2$$+ zJagl=Kt?ogp}#wv9-nofup$(yzK4U|ApZjf*1>I%?zoZB5F|{WNrG=5tMc^S>6h_8Q?giy{C5vN*kfKvbnfPv<0@AZTpH}eY5zUXiPauVHBHFL5Afcas+6|>*WN9 zwAXIZH$r%<=F^5jbesOE9tV0v-!4_)96Q(vR3Z*9$XocBbr2q=kC2tY|AhXCJ`{Xa zv`sPvd`-2|dS?i>($C88AzGxLmVH2;V+=onoGzQnr9eNqmZ>1?%AuS9p0qU(4Z*(D zbF=Le@KjB%JdpF% z=^uhuLsqvFZTw!y{OM@emjT&bj)#0NLD3Hx_RtFuy1VekNEeXbN1E$bfEdLWYy~!n z`rHblzwnCQz*Gj(6jVj*<7IF@s(dHB;3=&xQKmx78MV2R4W8H3J<3<$JR@S5Ch_Bu|<3dwy}y$%mI5v^{9FW*qf;t%7b8=qa-L_ffy@Jh-Dy}Ql8Qv zw{VJd;2eec__@|VqSmq zkhjA5gZ&4HbWp;gzgcwf05DlDX9wpU4*&X5{i{DJe=8KT?c_>+kSl;83}O(tUUjW@ zAB6JvRA^s*ER^YAws*O$5R>NBJfophx5RYMd?-N8qDj zbD#R@6s)SZ-Fb37L`Fo*>V=@}Q|=MF0h{@Kxj5qWN)&1Ke`M&GMTU+vfBEt%na5eR z0xT|StRGp6i;5D4znKeGoEzq?YUp6o!Y=eHUU<$R;&l&i6_B)3>U*v;lJmXufjQVXTP(!j#fa# zSXeoBXmxc3QWAr6!d0RC3q|h-{ZRUy!1T}na4(F8^tvG0%ID<_ptk5MI)VIxYNYY= zFSr{!HV_RdODgAg_@!SCl&?W_xn5sB50SNcvi3fN?~5ML?+2}nzFBVs`inAEwg#$@ zM;5S@5CXK#vH`C{FsSd-zlNfE+E%?36#bwr((T~CPPzN- zfw7FSx7ZEBM}&%=AiK&exe{a-3G0BqvL-t~-r_Pjcmh%P@yG`N{!>h@c8TIc@huHO ztP%-y0&zoh5O0E<$O3MG{<)?}6BKmIeb4zgWKB=~+SUrvy2ZCBcoPzvUmKe9I;2#& zzB4xpGWRFs6^w?0h>WRr8|Zf1d)itMAJdXgFy5XQgj0W6KDa30ujy{u=G<~ zDbIuNdbNU*0KPrd?urEOnd;|aIv7@o#$qdoOzIE`>?9Wlh>K#bm;`Eh<)|13#@b4f z@-mnf87it@g2AY?RIY_^qP z%2`P3Y1w0X8*U%g<1KM(px~wasC)s8;a$c9t!N|K0J^(Pl?Unmuj@Cs&6T<@BgH^kgOVicGaUTV z9V?uVL-Ead&syJwsI_??T2mk})AoX+Cm74?9po{PeP}~%kgtj6q8gCna`5l9i>pW& z!R{LUK#&dPEcrEPnX-eN2ljbdzV;s2OE`bj+k*41zDbV+xj;tCRzMR3cHl+g$pgm> zc|mr8{2JQxawz2FY2)>H$UW@btee1kQa`3|0Ox2acm?Rs2=;>;Kf+z$BtnS549pZ;XbR$j zsKJXMz7SUNEa-dX8aWs2)2*ND%^`bz+Nbs;xSJIBQ(hJ%R=u(-=Q<=FxKcYO6*7K| zOUmC1*2U>p>;a%Z>*%0ofw)Zz0I^LB<1L`K_)$Co%5!1|uYq}$a$JOhPpIltj)UKm z>O7?)_&%xnD8GWKsfvLE?3Dtpm!3R#YD(`+?b$_fW*GuP0jTn z;gs)YuNIIo*WAPy0gkasoOl+*27cir@S!})Rls~tw9a$)!*8Vmsodo*&{)=&b;0ni z@hjuE5OFqgM#QgBvVE!Ur7wg3Fh6`-L1?RhA>R9;MCtJ9{o%z(n26T=_>`M7&QXjm_oJsf=BaYlC_ zz<~!3MHtT@>Y+&EcKi!d^zU;;Yq%Z%8Sa|?c9ZTq{O^dx6afk!{ApxU0NN(KwVnZf zZ+V59NXDODV@Qu3=g%Rzij%J!_qkWnQ^T1P|X=!{kw zgW=}Xn{US!Kw9V2ooOF~oG3@?!+=FB6U%X>(5nCCxj!7ZCO!^#D*pu0fQlfy(viAg zyrUP$IS`U&tzaJmC2!|q{S+eS=O4440k1@7f*u7TLoSwEfzqO%Xa({hkpuy%`}K>t zQtm~4N)icjJ_k7s`WSt#{wp}*v@-f~u*GPzwJPB3r@g3O2EB<)laWAetYiT_xkWBG zBIRb;4DyC(6=X-q_H#DVc0=xB?OR=f^;_K}&wxH#He(jBOxBlMLDrI!nE|pfLum%8 zzt?2d489rRKUq#ectFKKzu8b?MK#5LI7D8qSjz7w2)-Fv-tsJX?e$wFl&)aeXDwX2FcsKzcrnNg8GIv z>gT|90`LY7$?rIXs|3o9r~5!5g{1=Dv0knNcC&*W;4{}Z&DRe~Z!7(CbZH20R*Z-~ z;9tWh#nJ$xnuHznYX{*yg2sApf;?+>t&AzK@wx5Aj|IY#CpRUW%!RmKDVaIBp!ka~ zMF5DmMNd(eqMjM>cS=2DuDk3z-CcH_yL*7#>E7X9_b5+^fQO=pXVCOeB>Bgpek~`u z?40^8TfNhLhZpMI7Cl$CaHYSU94$A3jFtX$fJ!qBE5csZRxvuZR|+I*{#N*>|h&i&{hxhHGRNpuZ|h$Tr}3R~w@zg8f@=DioZ58Cy)@JDGV7sP=$jhK7$tU>| zp|M&WM%=Em0IE&m;(JT8ZSd|ty153kAbLXs+S0egOZbKED1=3V#}gm^4SBv z?*?TX=Yrvu@v`zcaGbX|2{J>UEGGk#Wgm`#OyVYacpUt{2u}dufyFhxm|g8KMNcuD z@*pxr2i^dF6cxl^(9`rUPn>+mgix1z5=*0cGGwM7vBX3BF}{UC#!^VSZKUOw$|S|Z&1Hum$FFvzHt@m67uo1XOjk-{Xkfz(Mfc?=0n<4N*_zes8rvDO2uL>*El( z#x}|EIw<3$O|}P0iT<5 zrP>>s4`{XY3wnK!!{iJW0%Zuq542UX0`Eiq1--T253=%|Ir?XiJ=EDlI|oVkKC#|;T zf^M-tuP*{ok1Nyx@uAXJya}QX%XkV*rG%nFzi$4ILCKm>P>g z;tVj3V2ps3vXlq)7iFH(4NN=LM#{Hfnq&B0^#Q}_T7q~|B!Nhm zi`fpe<~FIg)_5P~fPipk1{~)oM}d*NDc=CE9o{DIGEjO%=~tsqLxeH%T4W3Gd&#Gv z*Fq?9BCM|8bO;|9G~9bWq|t-c#HMWoTnT50#gs3223i1LQDPat5r4`UUwDWQ}u%X=@?*GG#R5 zfWzz!7?nkgy|_L_EDuA|0f{&jXDWIQBbNzjo1B8Ldc5ZXS}9> zse`4sx*7;z7k5C$=&#Fhz%2P1r$OeDjT4W^UJ=6+0C-4IF(5!R6Hikdgf4nB9M~)# z6R&_a-1)Ws1!Vt{`l)>ZB<#O(K1YMt_>;9VY;b4f`I%XnkkdY~Zow$f>)FTaD?!u| z;dBHsLUa(XfLJe<(+e!q6^nQr{NvPJN(%@WWvr@B0-ssRWn~knO~pCh0gjVOHi!&& z3BilXIK>alhYTmwa$q{8wo<+a<$dK9r7DPelqBMJnF9GZa01@0KK0@&xm*4UbS0J~ zuq{@D)GCm?$9s+G1jKIhd)fOfNPWR;mdOH+S;}S68AOa+$?o5dd*lNGh1xwYGC=kR z#ak(^L_=8J@QdN05PiFhQuY%FF#DhIZwg`416O+ILCOBbCI(Cbb8)4I76!+!pB{c8 z9zI+A&A$D+;JDwV4vGFC0~kgO2p@4+ybTm!yRXYbQNq2@bZ_BlrOT{#mk5k@kC?ab z-hZGc5a8iK=FuGdJUsB+=lBIzpQ?RWaWCYRa@6NG#9d5^%?g0D{@Fhj?1W6O zj9VE&5OX4C{f#P+F)00N`ZpkZ$?mcn@CI**5j={i{VqqpaO8`{A1{#MVi0XXEhkIJ zfe`qaE!tTbqBrGS%-;@CFXXPU>fjykysec0a$TwWva{$U>hb@l^4F&n5g?Cni#wqA z(kJT&!S<{6iCzxurJWU=XTTA!uhT<-NpdbrfP5_YfTOP5En7oQ2kmn`8#3Q;Ox3$W z&Ma+}u7M*-Un;8sFVmA9Aj|080k+6z8L!JV$Zmd`p4xi2K&vZ^4v zJKxv4gHl&aV+7Dw6o_X*HHw=|0q=V19%V0LtOo!9fB;EEK~yya+6+%C^B`ca!LAMl zb7v(-Q~^;yT_S)OLWu-5R#~SE22*o&l9B-C1j7wO9Wb0zDu{z1c8Q^)7s#XTfIynN z`+z%OE8gH&Zh|-^*U1B5->lS8WnLl43K(61 zsv^3~@OMN5cOG`xx88Eu^T+PL%I-iwQT)sv9%3G?!Op`2&wY;neKr2Y+$;IhR=8~c zSoikPZhL>E_Q9uc1vL*VPS6hNU8NNQNBi_Nje)+`+UL|f2Lsl232gc)1TP5vDSQ+F zz(7C0BzMmkkv|C%7TkR;HTW)^=acQ^oTT8(9vGr-|n|8xEMqmPzOqbdfgylpx2OHSpjm2Tq0+K+$G;22@FX- z-x!WS$gZ+2e78ZFH4TD-8$-G4^)>~yfUpK7=X)Ok^Lno@)KkE2*|>X6!!IyfB5_ULNakrI;?2jL4_p+QCNUjr7|yo$P<&r`=E_;{;V&C zOeLj??G)VXbuKt-8(dF1ayYFtB&A+dvws5Xa7Z8JeYeKN*i7Q zW4L-%=>y7(;)qxUvQS*`Ch25xZ#)*AxJ3$(B$vt^;M}boRGLF-C$9x2e~8)Sciw9! zB!zfqm?hXP>buHr5GUn24gftK@qj=f&-0w@4$4|(w|WR721SNPJP)O3N3So_00N@? z-}UPe<6r>oMj5$gI`MSHJ-(d_ ze;XgnAWMq=v<9`DEGY*<&@Jm+#~~>DMUH=d4TyRp&unW4<_pf<+Rwlk(U{60CsJQj z{N1aEyKDFBQi2H3Z^(Y~9dK6CJLr4Cy4-O?n+Ntb+F`8+$iY&R6@VuxMgTaUklu`d z+#j@!x(exGj_O)*$jQ>))#JgT=u2e{V1}$CH-o$&pJW0s(=br^8vF{1Z?nWf={a@p z2Dg9;#~!Z{QW~OaSE%aS4ZIzGl?`2hH+c*nkVj<~hJ#!$=W>I4slpx}O&;L@fR5e$ z-(tQGW8*d;v2zzt@S+@GAdtra6(8X$FcYYNPJxU8oMdto(8%QiATZzu zC|D>7sQ6M9Fc2czy8k^2SJ>b|3{$%^ene?1;s-)go@E&DvuG+_2YZxlnl=YgOU2s? zUV-Z~jt@^C3pb2M&ZGrET7w(YbL)b3v0$_|A4DG!Oj{5GL>=)0s8>Y-AAt9p>S^VB z2pVYEsGfmV>XAH&F7r^9g7_6QIwXCQs zG?2Nj?gCtPYYDiQ3`8?mmjTk{Vz~{p?#dJq0(aL~Mw)UUrog|fcP=EY@h)L54fgix zKxI9MD{?h^fKJ@vE{|S7ps<_3VGeN!Sjty&5%_KN3-GH8W%`sIRxSa;u7tlH{v`y? z^~>|x3Z?fJn-x$W0xo&KrnZGkPh2rwkAyknSHHKX1?=2^YQwD`L38MLr3y+Dkt${Y zHtY|NTYNRnW#8KCvRnG!w}ZhQ2q?Nm5gr~29*x1w!vo7dcKmC-?XvTmyX@ng?>oHc zsrg&nDgOIph#U!q=1L0@3T;Z(I}+U*hN;g-w0s>ZR;rL%_I=2_l{eCP2yVqC)y(=9 zGF#_PEa(KuU6Ph1^@Z4mvDIRBKz_r#+j)n9Rjd{3f$~(K0*_9Le_;)OI%bSOW$`>M zKunN>m<>T!ZNd=(WwWxA^FttNOx^;k6)e8aZ?)CHYoa;TL4HgfQSNuIThb-ACn^(8 z2U!)*MMvzN5~I=iwI0$zbXexAILoCNYV6Oi@!r2FR^?1^EKV*JTU#;z`~2@Hcs=0{{}xv2q)*lO(^v<)9x1e5ff_ zgD5LLRuX_VB0xO>v=RP>!@#rR8RK^#o>QJR?gdIRTC4&}@Rsr!5GtM#r2qvp5kLmp zr5BJOKa<0O+kBya1pF*7Ixm1+tzvuRBvfUX`!v@jxbfWobagoAQ8( z;-cU0{w@qOJSb>5ksvyWfs_W(SZrc8FrP~lK;8%06`i9YzSHFf+2i1fa$r(w2*kgC zDkw7m@;**6SqFd^p&ye`AmWt$Vj75&Y^6JxyDJXy7zEZc_E(oc@Kc7h%1Q7lp}wWO z4WbWEQ3=SU92LMYTk%nT1oPX*TI$YmC9>)RoZ}960f)QWKtqzr z0J7v)avNx!m1!aj?*8g^%={SKsObNW_hXRslJ`k-A~@aUR1Wx0@pbz6Ly6mA&HX-th(#f-d{QAR zF}+`E7_3@!p=9;kgo3f)73FNC^#nc=btwmO(tRuZr3oegL|H-z0KKv-kQKn5 z<@{2s1J>5gZ?&P|_&^`2#RIG5DmH+u&SlcUxbYWIpAbsC5QwS1n!c z1sTs1tOIG%ACn^in_5;h0KZGcjb1?Xjs`tKUV_Tko0ShO0mYY>OYw~Z^KkE3YAN7J zxmV5w>7)P5=OE*`PA;w$n@8h&_wZlvPy_&6HN+0m02{aEGF&VBNgyhUxk@PTidbek z4`QJ@#A^YtOqt-724cEW-Fy`2t-NBg0F6bG+5(86zvv307=6W)fGT`Nb@#g&aE+_R z-<^X*y4UX{4%hq3yCBo#k1`QRWU*WdoRw|0LBKb1vBLs#qORLc1B10s3aWt|q)#a* z1$?SEurC04R<_c513CrV0L+vWLvdvel=!PJ{2y?Qzeda`AeM;Jv;omtxgnN<_Of%G z{w1U(-9BP{9t=ey;SbA3MC+DdC<(j zXb5{Fu&?*KP-9GC8fd!{hVRrvDH4m8J+N|4$Gj@XF6rTzUh;E{p zC`VB(5xB2=KxQ+S9qTS(T{O;R^;Yiv3Pq}|o8sUr zm!0R1j8=a0zQc=78$Z?MkjdThjJyr{5!pfBf^xRv#RF%-@YvodO_QPR_+}&Oo&_yI z`M@+8;;JXTo^=&c)@FX6{}E)wWL(Rr3pcoS?pjC4XpyliV-|3gtMW4NG+jhDTr0j0 zO$y!Lsy;AkG+C_^t$TL4D3Q6Zl+t(ozp-DNKfSAVS2G!V8dSG3&u5dvBATSXOsQ6F?gi(ZvPPj4%B0=WJWAX{$C>6DAV7!)TT?DeO zc0BI`kd?LNxv9Vy{hGBa$m?>rE&($o#9+Wc01f}@FXnHcqai`m5RC}|QC`gA10a(p zMJdQDk-gH<32vIs4bF;zOC|T7N;w4y*Ut>e91FJA8Jp~FKy(znQ9z6pFNxuxb`T2l zz;B=7O(hUQP8ow$AMo3y{-ibn!%~F|7v<1r~Lw$7|sNIz7 z$}|wQi6R{2X>OCuZy5sZi6a$Al}qGyaLiX)DDxokGoRV!x8T}>fRa9|AkE(rW1I%E zo%lt(4_uL}*$en#cL#hH4RV)k$UYGHVvBeK zu-?0_MTu;;^>>+^RF{4K8<(Bqo(DUIy7%*O2LST^)i?0q;lJVG9;7@xFt{E6!W#Yi zhVp0nx$I}|+Nsie{_6Ank8!84$=dQIxf*Cg5Er4@=9+g)w1<(~`o7VsB2<5>YCy#o zAahzlIp@1@^FZQrnWZ7KP0j$T8Il$yUb-^{Vsl~=W5$7XvvqXA0AMHk!~r0PV1nK6 zSrn7y{yDBsrMQy;f1wm%AZv@BGy|{3&UyL*D3y{sub?HAU6j2%KMn$>*lo_ez;p7t zOa%FyXfNsj4)+Rqq$@R4R3(B?(96hNSr%;XI(uq%ux2{nb+!SguKlbR2Lg%ZI_O?Z zWjEwLu3gkiKw2aFI_(5xec~*xtp(>9d5%uN9C=DE0)471#z`>Q0)mWPp+u9%ZUrre zs@q%s5dJenkFMD);5qOa=fBf930Nj8%AY_w^<~Ted52i?aMcQXMrjX!5=9~aAaJdK z#{gDt%2^<)iyzhTz&7=c_lqC`4J`v&fHr3!i`gLU@{U}Fs|4T( zzd8O73IYWSpyEe$5M~i21_KV6F86@kD-GIM;3>Ucz76y&$DyoiKrL-sZaa{Bq;$Rv z7zr0$aRmhGyI=c3dL9&}a+|QAfLJEZ(H2A_<)T;&j*YfH`ejJ`_{PlKj&O0~zTJ0g z!;Q9w-c9=ia*rn-D0l+I6@7s04B~rbz4!=}2yvV@!6#MCQ1(N}JY##c8UzkBR8Yo) zVSp$jz5zCoMm{J5mDj{$V6JQMHuM0?2E#MzOi-ICXO;JHWq$bs=Sd_L*V2Rp(VJ@| z0>|Wfc>t`p3JP=sMP)=ahtgA{SC_2~{yY2zd4CNh4~8fDXF=qF;OBheAuZwV@#NyL$g=+2 z-u2(#>Fx~Hk2|_-!NkJ-+<}1HfAtMK zc=%6vGzKLPe;NPS@$b{eWoLGA+3@b}4R*IRQB?58i~;mP`Z3uaEXPdC)DU=Xcgv(I z<>1w)dp^}N6~fy`Bt%*v>6i4X`HLZbSIU;Gh$ zS_Q2XFqeg5k^8+KqzT@iO<^s665g0V`iht60LJ!uW4Q++U&|X|{R}F8oi!j&LP)Z; zqGK$G_vIit8)Oa9Q#1#1Fros%cwqri&()SsA1EpE*HvKAh%G9$H04an6z|- zGRGTz7jg%xCAWGdyaAMWwqm630x*s@$E(di9?~nx7eKx$8?%RdD`$AdWDoyC9>@TI zE2Uo}7qD_eeh8wXSfG>!&Z!-J4}((Icp~UAV7IFK{0yRo_(`1t(k>I_H-Lk5b^?WB ze?=Ep?Y{wk>Vhzf(&7z}@p78}JkVbsTaXU&yrWx2V~~N)ra2#h+%Nr|ivbH|#TY=r zM1=blAH?T{bc+qP7QHA5qK6VAmVjPGSL6Ul`}KBW!OL)I-hmFON8n1>p2>GVg^Uq5 zQ}c3xP0s83n;;xYjF z>tDxPhnp+>-|`v*`7aoB^$dugiuHP15Shd+}xzt z=fkv;d6}S2R1%cxKp?)DC~8^(_jRdqx_?>oZn^CEGcKDu$h}`-8|z$8X@H0S1rO&S zRf2K)j3x zTG2+d;bB(scU?iblLPPjYGF<$!tvSXZev@M_=kScG0d{4eFr-HmGLc|B)H>|koWrm6aS`>tJglgwn zoC@m<;i08Rc>94`*RW5i4|0KSlD$A~m){VNr)J;7U%~?w08ju2scZ%;lwmZ8AJwDY z4iL{8JBDO~xNaEk`y7a>VvYJ7$O0KFrvWXlY?}J=P zCO~%Q)Gqd^aJB!@*6GLL{EItEC7p-V-dFnO>;&m!H|a+}6jNfvXCR&uzt9uB+bR2% zwGf(O>aR9}pcaNf$}%u45_QCnz|Z911l6bi?i5EfS$wh1h zBFM+a!>t`4fJ`#U06NlIwgRtaULSZbhO#f0pI9y%A{rID9vKKho&D!{)rT@aMS2I8 z1E1Zd#st8@1;-p`$HKIQU$5Vj1{YeyHb`p?V!miY42Y*hBM}W~MN0J6=C)>+ksrJ4 zg2gU7ww}vof9u}Q6A19|KjGmWd_4Rm{B6g-P*?p0_rNwI#$^MKx%a!TR_XypaYgXu zWf@Nf=zC-vJs!$gikA)i6vo8%zue*@X!U91@9Mk(1!J}I>TbAsH0jyQa7cS1Yjpkq zNO>>$Zt_96QS!RHHWl(S^S{oY0{rL}^9v-9AoqI~od?^$LSbsZ>;KkKj!0mbXi8P^ zS?{Q%&4=<^v#RCIgy`Iy9R=TjE9* zL5`85QY{qLK zughP_!sGCJcp&)80{{{oD_|u?P66?ZXli@|L_1SNaBC0^43~p?gXpZ(GPZC#{2$|T z_-_<`h`;(O{>8Wg0!BhXc!>()1CVEB8?8UcOy{1ggCLjL$EP+2IZdx(dj&8PC0@W4 zNC^Ag>pZypQDpFjQjvimwu{bU1mr%EIn|L4*FHSnKD`?JdU9qLo-N8$?&Ji|4^-v2sn>0-?Q4&w?k=T#O8oT5L(JV&b$Y1G`q1nHUd7$S@!n!5ZIl4dgHBeApPZA+yrq@%n>~R z8;&BRg;cmO=AJLh^Det+qsxwd&1JJf-21sj1PP@Z^VECa*|vwkAjSljTi)vkF2(!cnFN1JD_FjLr|k$wbV-0A+u^; zu=4=KexKAXvlwK(m{TIZH^g7Lb^KOah%1QmxwR1-9USEx;lKtqiOuf!dax&E{~3i7 zoD{q;fea8Y(hiJfJw;B1lCimJ!7Qk#XEx4DfWRU4Mb3#pl+2ShkfTInQ3X)lYeiKk zMhI|@MDBtUZLeMttS>mLIR)6Bb3UOZg3OogWPgyYi6IyA8fqo-e0N|?WcRBD9odOWMRn2=dDAP=p!~KDsYOc=$z(@!! z0S9;a#eMXH-|OYC#3fd!;zvyo27+h`a)f@w>I?cLyS)1@NMC2I?CwA=XXptS2*RyR zUZgV1G#uz4Hi|?#gHV;FVg}^DmfhGf5w3MQF(+dYoIAN?MdEjmwCKXc>;@p;wO!K& zfrwJ##AhJh5qs$mz7y19%5@0qW!$Tdf`Djah&mk9ST^$#V5bsQz<5#Jt+ofRGsY}K z7?{qfZImBDWQ(cdEs%$Zt2)_@#K7#920^)qe zLEZ)9*J@i}mE6H;pcA)9aepTdW2r!47lChCEmwiKD6Web2%8XIuGk4Bv55YIqogZE(54KQ;N$Ud22oWk) z0R`BKkXFEbfdDGF%wqQ^c-!sjXB3tYcme?){uCar!NtS>Ie*9T-{i7Gwz%vk6I?c+ zn0vn*xApt0&;OrNDC%dBZR8wKt10zF5OiGL$g7-yQ7;Yns%;LG*jeK1k|!YXNJh8( z8xS`&`E*uu$f}n8Vy*#V-nh}?#zsiGkytMA2FRb~di@*VRbCfw02*2mid_FI{IR0_ zCGi9`Kx~pfa{@w~)>8J7P&q8KZ*F^tSdxF(b_!JVy|OgOVq%bJ1LR>q1tQ$yeWhKh z{aQDDqP`ETx11xiW?+qW%yaez-Af*oHsCe}%uvu@-y~N+>LmL+&W(`X-q~0$3l8+T zvI@wla)JC5xK-HKwy^4iH^=DdYVXGjxWaNt$BZ&8Ch%d<7`iFb~ zGM6lzcpQEYMS}ms0D!oc;=dI{xaciffT&^kDd-A_F{UeF`5<~JgN;^@1@ej<#UI7` zJa^Q8f8&7YLL);&V`%i(8BV z|8?qjN&^U6XS!r~AN>3cla=D2%%>lLJ7|EOR4e_4kF6)2Ay2SN& zI(S*_Ik4qa@Es9wGT0B|zDdc-84QV&Q$Nr73Nor@&d7QOuH|0&=}I}saAu54e-h|U zPtgmgK}~Ams(mbq6R*EVp=$qmg7I_J=+h3oLY+;u-cT+vdvgA9D0e+;O8#l^s^zS$ zbpgtVexfDFgG3Mv__!Q@(UdYofxbvKl6}Ay;Ed9aLP2qd;=BpkXS&dP04?xA1$&Yl zA_F0{hkcWF7Sf(`Y|_qwZLt2BOaZ3KU*#guzu*EP;CmqQO|NTEC7{jzVyRGbcbieg z-i44R#ieB?hz0bf7|1(rhu^cp@1Y3ue-Hq0IsP_o%jF>IiBoDkh&N5!!ae};jIl|` zUJ%ht5c@#dNMP~rj`Q$m;d-tZ2%!~_&t-;#OmqH}xe(+~`D9qdQzN9x0JF0?vxf8xnQ6>wURGPG=y-d0KxN#4pNr z@d>B{L@-}L;1xp~bvA@&o9?Qgg7;|kgt8vQTLhtkGG7=)ESSGCv{R>o*CgXXLl&rU z%3|d?ka1*^10<0{9^j7yCx~>pSZ)WcukwKigxhAHx|VpjJTP#S?-!6EEdfRwU`Is( zM$1#&;NcY!v|+;z)T5@X2A0PyV=ObF+^7n3D|kc1`w=B0+e63&|4rVvpiG_OLjrq% zd94`i{1Ubt+*AB`G)!Ckb?CkukWekPN6uwXCn|T8nt(sv7%3{Ef%gXjCcDfMw>aP^ zx6Rn;-tN%|@bDk;a1A0J{^$H{RsX^o{}q+|S(g%Vr`;|6N zfuRGtoog@}o`2%$h0TV77-3BDSq3-FNi#A#LCV1lnHKgo0k$EAlOnEv1kA8uXXsdcFlqvyfNJr=e0pt0Cbv;4yp0 z^oX7iKDy*{-s?c*h%+J$D`Kf9~jz<1&{oj_zOv&6@cyENk)`zp9FY5$ni>2S8#<|B7jLq?UDX?epz z8ibrN2C3cB8n zfH}lqRojEoPwW>fKpr5L1Rx&`9YlNLxeFYT8{{F#yJ=ivcml4C4*0^y4zbn!S9pC1 zwi)VoN<0XsoX^idI0e{w_(TMSdmMRz{<04k0u40{jiJ{1QGxd#NJ*TxXw1Jqf?`+Nphjg;H=7s!538=#*9`MRvdB9K4m#pEzBjPx@ZS3}tk z8owTT8|o~6>b=Oh5LLUvCw?!2`i^>pc#u2ww!8^4l{*yRariwvl>83@0ELc!g8T|Z zCsEB<8^lg?Ze$7wv!S^EWZ9%VU{pR*} zASdaHEe2O0;63*-55A-HukZ(vJ#k2w=mFwYahGn8k&s-{_AZO-KM=T^17$?l44|x5c_7FoM{3qj8!(<3LWIU$Eg5iM3Wd`8QW7GlDEJFqL zOYnNn_^e?F7*o`}YCE8lyHwyJNu+V_UJ$>?P4XD%UBxCb0g}6VUo@w|#c4qed`m-W zV@m_m5n!gMO+x0Z*)S1;VWvj9XLp|cajV9`-j!!_@F z@G~&)4+OZiv=%+#vZLH$f!R^+?Vdn@hkuEOW3ce>Kf~?#tL{JVtEL+8tIN)Q!Da8M z`ak%Nf8paYnG6a*`$=!A--L>?#Gs%o7?(U~Wh*N*E7R!L#|A+5@PdwdEX1_EQ!S$x zWS+|TKEEW~oD(}L_AbP~8aMe?WzZheN@$_L6sC(AxKa{}P7T^W;*aY6-9!iKg5r=h z{eU1`EB(I$5(jC8C-GNb1rLD0;MNM52(pr#QiJAd^g)388~R^TMh_g-JjeYvK?3|S@8(g^I z!B_P!Y~y!QUgIvvs&b|@LA}zI8WcMZ<2${$q}@kQV@}mYl^Vg_eL0=&d*J5Ni9VS| z$owR`N$voM*?VKwbqR^R?tGcp4P>H>)vp21&{aGO=;#lH<6o%WAB!JeAd8EEv;m(t z9qY6lsB}FuChuz~9-0`TQt#NByXTcZa+!9d4C z$273*c8=4+flKUQH#ob>V8%dtUx!`OAO(A{b2wOA=t*)XuvDIvUxB_+To)rDcy2kP zZzR-R(sfZ(1*l?foE$m}ygv48Z4e;8(hFoakXz&m;s6zcXY}*%FClQPoT`A4K*B)y zh|*L8%mfnwmRiL)3>QZQt@9lYspBkBrp>?w5sV)&RG#M+4_9V@0Mbb#6?m1GCt`vtL)u-W~&MpWU_NQgv`D z+GF}W5UFCLc$uQoM)3YXz(SXux6Nh8Omo@%^6ve-+_u0I2=MTG4FCO0czBp_JN|_a zi~An+&-8QInNPcH5pw)h*9xy(DR;^%ATx+!Ff^-Ib8QJ9m~eB5xnoBtn^bmHnWm6b zK4VON3fwG~^iq}uvQo1i%UK0i$6PsZ`81?{m^$+A7Qh=-06a|>(G8d5U$iGk(tW*L zQ=(C#F;zfB$!TnW$jrPUwi8gzn4Xd|3PQ4MEgVTe4wBD6>f$xA5wK#$2%;5bi2{9u zjFuh1>f@Z|>;eTwd$98o=>=ZhPpA}zaABfG0pLz)xr}S4YgIFkXl;?o+ z%4DTJh{j^Ihy}uE#8xam=r_`zvxCM%rE#KC623)#w=tSC1IJxn=&IxTHZTayxV+(tngm?ef6`xq+A5cTqCTZ81q!{70>Ok30<7d)u^zG-X4THR3KtGuIC#DuR6Jfusr(Vh z{(6c$2%3-foW2>NMZ}b_=V0{p!N)sY0N(>b?uo88v-SAPHx4+cedF!1oFa-ZXW-x^b^=`Op( z-QKVCUiXH=8Y5pGRE!uuyi30S!)XM)H!9QL0E${ox6sJcKS;?-(^gS%{Y@9(+uiWU-3@u3os#wM8o zvWKmAQWelQJ1(V9!j%c*=eFK|^$GtU;=qm$Vv5+n;~)x@FT^L1(LDJ_>vwQ!)z4{3 z-QfINTUsPO57u&Ni*40GnWF3z6F^xaZtyAuI1Faxb%>~G`pA$BJ|;Cs*$+gy0x@bO z<(e`Ryq6h=7~Tf6YRFKZ0C8JP5<@{AC!R!bx1L3;mD}Vg&>M=KVhY@u=A&75!iDO= zM|?km%){oL#@)bNxsUTea}r6%wY2jvWCj$L2s}v}*$T{&<}T(Jq5L-$4p(df5z`|p zMm`B)?E^pYQK4+d;==>Gg5KG-GH)j=`DnxC-9GSTnI9&doCmo>3uZdnfU;hBLhJ$Z zvEEy6e{iw8t;uC<-?{8W_d?x_&s|n?iwI(LX97IZTt+n#~oF=74@9U-nl za!l4KxP3D}tt)1dmD^h3E-q1fm74Qx>$Ht>r)333wkMMc2uPEjnZ>3>s}l5N4d z)6w5q9SY2j0_SDWYskye0P-}uxe1y3or&5ENLptbt_49}E3Jgy3g{z~ zpkl!n@OQl)W`czfr2N0gSTHxMAI(h#`7 zCuBjEZ%&Y-E#ySxs?K%)Bmf`)8}V{Jh_{vV=1)QKvD7Nr4aDba2TN^`1@eZwS(T@q zUr|SbFcCoykl)K)&Pkw4tBmgkvW4czs}6WkUVQM|{*NFMKnYfcF&6YbdRN|o_{*1n z$^HqBR9?3$VI;)WJf^070NjllbmX}sZMFub9pD)T{JC53b#9V<4VCh6pYxGk5<9gs8Cw7`%B z7n6g=`8^GBv;7)bz5;!y2oZaMALJHJ{^7eT+D}c@U7|IF7vvx?)G|D6cpl2kFT1d; zgcAEo{!+Rkgv?M zFOmj`{w3#p!8WKeA>&YP4ERJiUUcpQX%w%DjzBy?*p zT7$i-^RU((DCeqawq@%TWD+E=v;XXT9MW1iay1)hcVs%RfZU_2@)a<)3CJ}*3stwY z-xHxi{pX*Fjp_`+SBl-STm@NDPL>lvPLMq~0vIrP91agCn6Q8d7f;X=$dczd0D8KX z{s$i zXzL+c=4^932_+jvR`fEu0|4`X_kKDB+yYTd^b?&x95$DT90y8G!?vIdkT&9RRiH}G zH1Z)sg76lV#b+REI=AMw1Rbl4e-`9kscItt13|R-t55VVM0cgui%OynfgmO;WyEH% zF39WT`~c1e?^W)G!->o5dncTNtgqq*<@Et&xwuSa5H@nf3*cABFkLANk!j{%3>NVF zLLI0WfR0!YpjJ|1lv&`NWSVK159Zryj9LfSEM5}N0;jo6%5SG7Zp-CzCpZr(dzEGo z8|lB+YYAMc6_o9p3Hfym!RieVIdTzOfslJE-9>wLQy2)C$uv0)lo85D>I^8oDSAb; z2GQ@ASyZMB1byTm?(GfbpNTRA4FIqD>Quco{8)cS|HC8T;~vYu-TMZlcF5XdtpZAM zWuC|ftoK9~A7t{})-3{<)zxL+a?j(J9lvjX#T^JJ+Qq9L{%wl(&FxKXcuq9=?Re3M(i8{%s_Y}jg0+P6 zbFCK?Ott^uSPXic+$iHgUSl6|kQw6Kq78$@Xj^Be9rBxK{pC<#k~|>409jng5f>n0 zPmOkgbD+_8y~0a=2IYQy?Cn4^sN2*?;ROAvKAiUe2M)KGnrG~Klo6;HK!l0rJPY!+ z{GPcW$2jNMy+MmB&~jryi!4~2y9MMDr{Y)!@)$458vIsE?@L)x6PG5s@xMEzzZ?nJ zNhb-o%YOMCU?PZOAdV{S)gVwiSQdGYg1m8>&GHrG4zw>cPK8n{qx$=-1%00Wg=`Gi z$sidh;F^3FgpZ+CfD@E>%k(HSP=*hb3%J_*UHLE0*~5d4z(4@tAdT%HhuT*sHv@gH zy=&?!TqOhL-Fp`G`{&QV=`I!cQXHcdh*_cpFF?v0@#hMLz>$FU0}?{u+R@$qDRH2c z%RlIR3dBt%R(uY|JIb5l5`?WbUQj1NcpuYVbrcwSixT2%5QD`_^ab+acz=JBKoALdwF7_PM*@cHe|A5}t#YOE(T( z?*)#>9KH?-EM|rH8qkV(8$T5t32dM&5rD62Vi5kcwUYfH)L5J5oxK`DzqH=4w*@W| zBz!@B=icAnRogFW5J?y~Kh=Zumm&X@y@R72*xESjYS#fX*SP}r?Xs`*f~1kQ)y~Ht zZHD8Zb`3Otna?ngOLRZ^2ABtjoHnn7TFamMym(uvJD`&iSpa_3f;*emg8WRsEjxoe zC^wUYE3*IK{rWuo-yxA8{HRQQT#4o?=yRMg_P0PAk-t5s1~}si$c+b?siiuu@>>ml zC{08cT&ekwQtfh~C}1uz@+^q6;$31O+c!U-s*so93^h%KXumQ&LVZB^nl^i#2GLa{ z2oq3`yM{zig1tJIIt1cJ^^kWe$b5N4y7R<5_vJ&51YxE)13@m5Z#epZo=`CR);^HK z^qtm3z(TaUUErfy67WX~dv$o>jS5O9qn^EjjDpLKBQK`4fFpyx35pvE>CS7D zatDAil}0iH#C72igTQa5VTDo~iqA9OF_Z`2M75TZ2$)==q6VpSRnozGlfcn`?lW)-XDNAM|ndCV2AvH zqulF4KvBKR3%joDW4GK5VuAQdEP;qQkzI=~fbxqgT&?gH1T_e_?rVo~-xi-79OAMQPU;g?p_MFZ=@~FTM23-WrHwNR009_X?4ZccG&^$1;G7>?mxiO zE#T2W{qJAGLs7u(_!qVVaj*CXEOptLJzcg(v-=J!T=RbLlC0g1zkW?tkQ2f3nDJB9 z3`3SZon9vtUftQdZ`-4wlrd|*k#Ifq_PX?MAazaV+`N4d$E}E4yCCMx8v}0SfYa){ z;(QwTlsV#a{u9T)u-TXEL21X;W5bH8z(RHJq1>Aq{I4FUe^l}BB05qR)JWM#Mnbvi zIsNlzz++wRPRR~~fadlWoR5KgP8=3>fM*EBAE-zOfxsG0a|vu~oK>9XA@`E4rlUVN zE@-N*g6zi$Zb0@qXNdkS#C5m!cP@p@d}n}u9^_hSmxDptl^UWI6c4VO790a@H@v>A z{0C5LeCyW5R)D#eS7o)UOZ1OqU=2y#3 z0q5B4g0x|vZMTZN9e_h>`WPUHx}qK6OF8i!pgaUC{Qn7sB}-<4#X=B@u!wVDTWUY2 zPXX)81&`SVfbVs~54IOTe&j4=Uj-seU25C_N;S)d@cN*vH7*P64>C{Qpo;t3dGIH` z9{vmj@E$pw1JOtss4fHE7nAV@syLVDrU2teW&HL*~W2$L*IvSs|_o6QJF@J`W;=T3v4KuAtXkw%&4=J^Z-K zCKYM}Sp5C{{Cs_JW@qQ-=H>mXZ{wk;@!&aj9{yC^j(_3Q*DVraa@PP&ob9sxWA8hx zaBBD9{XPmE|I4zxoB&>xO?T8L@Um~0cj{J!SHA64x$TF*XQtUc*Wg-y!lv{qkeZiS zDo=--D`S_()`i$PG1G381#PqTm2)mIo=IXd|BB-;|6nr!Z{P$f(YRu*77(Mc%grEm zlP{-&sDj2FAO?jne!oicXFWDtuVY6=0W9KWI)G)Z^JQ%;)SjQ#EIS-(_fAdAz5!mo z&K6o9kcxO!JPG8u+x9i5EG0lTm8z@-d2Q@=hZ%BTw52*KfhP5G`WxV^ExqIjNc_lF z!Fd~ElMBM_t08ZVc1$l0a(BYMz@C>eJ$WKHie;Tm0J1<$ze@&v zr8C671qh*$=mZ2&N3`a*l^+j(8@G6&C`otm7Vv@ogbW#zxD zqJaEX&f*&ApJ+#AD+o@F*l#`o?fVQ_SGF3oe`ZvzN@)<-vivr`F`&OLcgZba@2)4y z1W1@{TjZPxH)~p7cU*<NJ3j0HjlPl!G8Y!v2b50OZ8mR@>9Sk)vS~xoVgG}D_Z^RLx5LB3#tQW33YdWkbknH>w3Ku z6#Tg7@QbBb?D2uCLyIO(2e#Ulvj_uUNSKYbSoRHh15aV;z;ko;A0X3|Eu za_!QjOEHjP%i5pg1=pJ=e4jA^(qrnZwepeN6Z=K=kn_Rn@*vvdSLKq3l(AgYon+kl}7 z7xX+Z+~BxA8&t*C*jNX$EyY9x*rVuT*b2_WR8zbFe_Uai|MX5QjELXBA8(+W zYsEjPye-b5L9Jq`BeI)7_}qf!_8}n3l0`nqA1FgHAOI6apfo}FgY&euS`UD{^7dqh z6&&wsH?$!@S#<1>*ITQiKLdA8*)pB`A^THjX?-2Y$D~Ov1N|NGs^|>G-miW!pae8M z)9*s*%22j=t=9tAgBUADF%o1|nZVb85wpip^MHHJOhkw_^ac5pZr9p_Ga`3O)@g87 z%DbKA3$nhxSxW(;ct#8bRLu93Odi}7m1^@gtr7!M95Q>mVx??<$O>GkSR~f`5gOg0Rqt zC{Xt)Ys6sio@k0U-T?DW!*#Vb@HQ<)1K>JoWC9`BaDa%HE95T7d(wEr@H+e&8nW82 z9K`MSEpM3ta;5l83<2Jjr-=cy|F}fJHCo?wIsVFI?n+-UMf07rET~>w(!;pt;LCRi z6IO7(MQx=8IQ#IJ`V{Eph!iz}1b09n8c8a@4^;g9^Af;a?vet`=W{s+Lg$254jTZK zN>v_HB@zOQ1$^s!49flzH7O_`LU#IEjBml79S29B90l*6`fACJD2Q8?QY*JCsLhoh zg*Qc|G~hngUv}A7-gDWs_3jPc?vjA~zxoV4{JD4n01p{%$N#sU(|@4fL6@Cd&1L-q z+#Bv|AMyZEDDD?8tINq?-eCMhHNwljUB=a|3PU#ZSli|+km*K0uMgqcTM2&Y0gyf= zt7-n1aPya#`7r@-tJkg9ZU%tfQE#F*1iJ97c$RA zQCQo*TvVn6h)?A~E<#klyp>j<<~M0R*=xXWzP*pr1hS;)FIof1cwqv{5ljFui@ov$ z*aDnU+EK`R!yfF21bvA9hWrlX&url;r0sEpYXOjW#@5i82DXE`kf%UCtGAV7L6trh zgAUcZbn=g^42}9c8&zTx1XK)_=9wVp>38KbAkWLAqyvhlrr!g!sX%N#7H<#1FPicjys^AD`_^4@!cNbiX>r z&tP}MgT|Ak;QgtKM(pr~_+fXC2#e*IQ_&X)O3!A#^aCbkLf|~9PCU+pf z{;#~ahX)@|to|Y4zEqw2rp7HNxa^cNE_=`MFBAuPa2P6aqj*qmv2-BgeGS z;60Ox_I&V~%%_fJpbqD(ejdd8*w_dhN2LsK7?tw;ma_IE2JsjugSn|s0A)5e^cR4e z2txm*D^gh7?{fT~6&P4sY$=nZqi|o%kjUX-JWziA1>vH@> zBT5qqa}Uu2D*b)A9UR_rhin7!$E`0rMnGJ&HQ!MUY$x=M z@+Z(glD*_C@V^{=%%?20tvO;y#qQ90{R@N3Y=eMBA;nECL4QU2Q8op6QJx?JkK^yb z^-DJ5M-T`zp_Bk^koC>{(_jzDxRsm(S{3W5JS&jFIridl{QvK9bv-c>NEx6aV?-|K z-5o#Xl>*zbA2?C+Mw! zI+UOo;Ee$T$nxTO@dOx)>GAppP-S4ouepg(XZc-6b{+7k>*%d*18Eg+@)S^j!R<}_ zYol`p0&ft-$&yclx}4M6W*`e!N#zk#%Hf(%l?4u2p~Ul2hA0UtA6drhF zEh2pzg$=<;@u%<|TkJORp^Jf~+T=6HNgx*GimdL^Q?0Iad$WheEDy-|xr- z+fK(<&VE20n$imLPHASn8N@BIo_2l#=@T5C_4Oc|$z1s&$OVR6NPRSjf6ApRe`fIl@w zEKpUZ>raE;$ohSH63DllD{SGQd|{~-bR3kD>Ij1d45tevak+(_ap2)Xg76Y$#aJL* zTo#Rh>CURzt$~*amG1%yW+MLT6D@)i2Fg3qm}Fp#jN(V|e_VDY2{}$JLB9ZoCE}Vef|s9qOo;(KM1Mt=14ntySN|N; zW1^!705w$ErlbMU1mXwOAxz8!QH`yfhM;e4#~g5QNP=3;o;S{%izZAg+^39vFx7ixvpVCNkNDD?s4;H;yZGqjQdt!RkmEy0ia+h2MC^b5RW_h6OX= zhZz&tEzUJsQ^=?6i6pvTCk zz;HC+hN(9+3>|Pex&?F|I$~JGOHeGbbeMM|(0Azuo&))VT*OU0j=zUO3LXDYiUY~) zVhw1c^ABe?1IMwfywp7){k8Va=YSGCD~1EVUrF@vAmLK~52B%X3*;f$QJ)HqDp~7q zP6OMelxNSr4f-Z$Y{ADMqQziw0#8Q3LyEM?I5`)Xrc|_S24*QuEdsC+FBksRXZH}` z9tC9q`DmaI)sD-y;GONe)ldK(c9UT$3WoETpcfzz(; zK(eXmCLV{dcMC#ozd)n+lc!~jgQ$ABKUrOK99Jg5W=azVD1S#CKhTw$FC*|{4#>9% z6B-bPyqA~yuTU5exQ0S8pcPIof$~ z09ed&@inA9nYKOkW4O}qlDISgGGnsZ=azvRWp5A4$c6M~d9luc(C*FVlk11Uy9Wmj zZTTsLEe_1}Y7V+hA1A{AZ!8aRH=06OSNAvI=k^mmY~`{o@6T109+AMJjc1BpM7dAh z-!0DJQ`Tia{>f$Ay?@_f4_@-D>T2^QUzM}vZcw)=vEnB5Y1l5YdS7_`VBh8KLP4Ei zG5T$T>n(1tPag|u&9jQ-E&iRjU$0w3Zw7!qQh!;0fq(A!7uNPCBk%{qK~8E*z^f0F z?Ga!Y$pO7Kztxi6#g~$RfnXwlt@>d7ILOkD8#XKGJ8g^e<3S#=#TGOJ`L%vs3kD2C z5Dk=a)w*dXD5bmzdIKUv8K5{inZG-`LQ%gM0`LZgh$pB4;av(U*$+UYh~((Z1c+Re zH^BM

cfXAh%GGFn(*_H&Xr}cZ2n1M@^>za)NDp>?&yU^fdhmaL$+InGAQnu*Exf zLY!hvb5sIbvc6aD0DYnyD;Ggvc=^|T`$ESr-fmTC7Bp+vqkYM*!P3%ur1~=GGjyGv zfE~MAu*c)JdH4+@frJ5>oMty@qw@D;*8@jL_QABvAUoqpv z$%_)A31Fs}s0mI(&Y(NtU`tE>>YNwozc_OWHi9TAdW$W10s#*j8u{D+QA_MlmVr2^ zhWq*hDt^=gJoodTiwO%V$V&1iD?oWo=_6i)Dmxmj3Em1_W{j^^^=l|ovUyzi5|AU6 zSt1lPZ@qAxps4tOUg3OSO<+G4C&~9`DK<*3n@s1^+pOc5B z{#$n-axh{5875v3ZNblGU+ioE^`h_g&Dsa$2WEH4`vw$$D#(|C4@Eu7^IPd+A!fh< zaxfP0B4}|`Ra_-s;y=nuEu3{&5g37UsFVby54Yq8;B}N~_EBJZj1A6WAYQ=1ejpXa zooVp5=f?i-K)^zlh^3HLGVRmUUT}HK<$f1;K&B=8gPb=Zrrw>`GIAmFv4W}kx6m=7 zRlkP$Fz)36;Vqtm;A8$5EV-aJ)i=ocfH&p`P-?r7!rTjYrf}2f08qrZPvpL9aimkMS9 z1Dww~tRSCq-n9<}1~_{USGS#5e&Is+85Y2 zgFa14Sq`ibdX_v1w~ko9aO6T#UE3mOCD3l`J!LbH9TgifP^NyfkHV@zmyzR>s!oT> zI~tY^ZV19D&d?lWD{16AJSzSk{x&KWe7IK`hW;pVvW#YTBv^$9+NxZCB*J#r&=K;NVbxd))jy>u9;qkKb*FMz&8M#|?Qv%mAO{x-zCQIKu_46?>Lujx~P5o~53SWh{6J1am= zl=Xn!1kT#}4ZSId29zQaFu2<2NrQM*bOg&C=P%k1Q2R`3g=`~KTbur5?i4U|&>xq3 zfKH+l^#Ox>o>REc;ZEguo}rPt8ssSg*$agH(@X$YsilE%O5<8+DGLb9e+VF4c8fRL z$YwB@XY!?^378{U=J*iA2J+?SKr#ycz(30fn9gkR8Kixa8kQOZSDwGDTp9?OhO7;_ z#~^0t?U@+{$T?#BQ9cWuFSoHg-Va92f8N=o9QgI{-fesz^rg}!U*ukQs|S?(GKFin zyNG?V(PhI%xi>txT4EmlA)cvw5#b+;{Pl1*+!@>0Wew%s8{9QL56}=(n9_DqUgIvv zVl-kfw0o*SpE9LjL`MG>ZO?%BLBG#}dP1x<@o?r9NLi54E_WBiy?*PRTfuOv*Udq( z0(856SHI0a68HP#iog5HnS$A&odmB*d}?0-%1sjGS>OT+#Q`Iwr~(|+SLqc&CfKJG zlmVGyUt{e8e6Ls2CIA8xUVxbzGzYwBKt~{g>0%cUjYH$-3?hz@TubH@7w`W7q5xVfWxJgAfBKcB|&ejkI=V3 z&bu~;y)G2&avXB52R@K%*$g>3+EhIgVwV>P`DP;WZTWA9aQ2KpvG_Nya1Q=izT7ToXePDjM??=uNETH3f%X z_K#`1L3Y&*+H*iK^+iX(CJ+S+xRk-pL$m#m0x(S4@ zsK_(!qaM7xG!OqK(k_$bcfdPJyy*bYOAIuo0e0@npZ@Bzdx$B_xO3n@g1$yC$6&DZ z^j@Tng63-PawWfnw#|nJR;&ZQA4Og9J^^yKUP6w7f`!_%@^!eGQqaeK22$qQn`@tf zK7*B<1jk72sP-&m53vrgZvuNGZJ*W+h{PWsAP6HykbOlPQ5)3yavgzCxmrfI+?G)L zLTdSJ16XP~ztk7~KlaW$N{XuK!_V!Wv^lecU0}&M=Nu(SMgc)3NK!!%K|x=|0E&Vb zFd>L2B8q|tN)#o7NJetrob&92p6>hoF|+8)n=rC|?sE>O4%^+bZlGnB{4K7tr8klngiXPEwi)Ua^_nt{@#=rw_4%*&46#T|nBGfxU zdSpkrkn7r4C6pV^MIWC?;Oy#NYpvv4;PCk=B{#RBlz*b+-g2b?|Kj);N924-l&!o; zv%KYdK%?LFEibMrFL@EUbaHWkd{3IBfc7UEOpR#_vwxWQ{Ownv%)4c~SC|G@&8eom z9+3J8p&hzS_GsfX(Y*(U9^)fybfGFp{BggL|>NFK9pN9gIUD@8Tp$kbPB?x&rZ+ zoYy=bfU~X9P%ZOSlepoQlh&A0}#pB|)*0Ls!sjPk8t>iGZZ{ALlrn?)tS zSNd^Sz758wuCjT3K$KC=nQjN=OWX6|PXac|(F`zf|DxL8Qc4yQHyJ>*xU3un*;2n` z?+Pe})s+KSC@W6g>Vy0n;L8jk7M;_eyr8@z&O(_Xl{5V(K!v$=BSIn})0I-)*#q() zNeOp84YC&Zu@DMQ=^Kn0pdXhj^J_ef9pE7Kqj1=8PRWQY>FDRb_ zZKy0uG5+wf={|}P!lt)L8cKR z)`58^`}N}>VsWwzC_-Qb%*0X?=cj>)W9GW)I81^)q%li90Gj_4V0BY8%$yiU_<)yZ2$Sa#~*(Jfbvuj zOTk{-e%ihX+~eHK-45`t8CWlPIk-O5Y8&$)R0-K17y*qeHCDuI1npke+M@g5*rE$h zrj`fetPv}p1#wLr5T5}?i3*GsfA`{?E#Jg(!|%K{=P|GSezR|RPN_)XUxU&NfWHRC zNlm_*oEV?T-~4aAHg2hJxlap#fLndQ|AGe{3Hnz?JL4)et5mZ^^pEh=)$z7o`=R{4 zn6k0kAijFq<-8-1`eat$!XQZbBBgSQKU_X@Y2U?RpfA(sc%A^pF;U#le{SbjteSt( zD-L7Y%n^MR*xbCK6@eH|Hr0Vk2%-QpF;oY(8WWASj+Spc3U%v$pa!3R5u4$g>42XG374;P8MFc53L7PKw(_?@gi4Eu=2GR;FEA&r|;ZR@88eDJ= zYFEk0D0G2oo}4G0Anz7kMI#^_3uYh;Kdj)+@Vu=zgn}DwJz6Sj>9^`XK z>FgTnQ6PSt)26iqcSR#yW`a>sE|9Ar>g{^fLvDvY0gwGyt1mQot;_PLZJ@rTUJ+>^ zYsq*%4+af}zQbq8T2-KS!`u6o8wboYofa>GamaW; z4uSMzZh!p&xVGQ-K?-^0@8W_FhC24`es_voMY$$rry1X`kV2`tT7=K{UtUGT`uO3jDjfR|4fIPkF9q2BZy0U7T_UTyA?Q z_|k01UXx!~^dnpxm$WzM86d^H$3GV)rVmT(x)w$ZzO8k=Tu|yOGsP;9bLC3;1E6@d zu}T=lZ-PFtajUNc;K>1A+jH!VXQ)&gpk!0>Zn08;e-Zif)%yE4^4hn`cWMdwL+aYP;;Nc;G!g6e|E7{Xf)@dI##$-gbW1RsDV9e%EXKi&OnopIZMF*+CY8 zamLlMXd`f!rtw-fsC1;Dxx)bA;T<-CTtgM2f${|64}8vX&VzH9 z_Lb)mC>rcGX~AIhmx(eMw9)c}90jkcswzz8B2Js;AhXHDO{th)DL03iAi{yOye!9oRx96>RS!J5g{GR@YBKC^iXP`Rp?O7g%F z{j;!yy5PB1*h!lVV!3!vJOhD6YHKAAVsEo0n!bU66g5@Z2GpPh&A`^!{GRC;1oXEY zFz*NPtQZPfH);Tk-H#gxa|&0Z8-9F-Y- z_JOD)nu(TBDW~$4%55R;t14%!jDa$*g#`qD2h}Ua+!0<8?340)Wi^Cnw!ih=`e0c9 z+P(%CCxOV|5Gz2m6ZJ%Syy4W67eFhX+xI=ur+i%k?(}sNIFnqwJTWmPB`uB8T!0cr zX$C+E5WbdYvUT zTS4lPoX3i)K;r(4r}BG3=JCw6nFVle$JrOpTEP|Ky5QQ+%{%_7D1?C0njF~{Y_IaJ z)&|s1xF`n!r+top@e8SkWG;eipfzz#0>TcBC}^dWiQL1jzb^$Th?f z4OAnH5MZSISZ)Nz$L^ilYOuF;kJILZF-hjgGT9kcgecn9QsW4^9{ z@FSM?xB6iJ1bih`qPlp8HXvS9n~75(o=`ku2N+khyNvdrt;&gVw**Jpz+WC3|7pWi~5}U1cK$I5`C{F+6lBY71>JL0GS6!_X1R~2`Q&Jgy4 z^F8+=XgMQ&Y;Gi!y{jn6bq$y!I#M1Cof@JIxHd7y{4U6|gt85YCW|v5o={Jkt^hs7 zM@mP)LlPJG>8=&NfU||_Gyy&`()DT}kGmrrb3l&vjMDr7g#dzqG)#npxP+bQVC}&& z&jc{_=0_tFub5zY;6FVV#SVHa+Rzr{4!P0T0P%;eUA_7O#P_<^;o1(!OvvqO9|>0v zr9PP39fH<{5?L3f*BCYQwiVF+v-%ff8iA}V=c3>(nJuEEaziMuu1~e$h2~xxcF4ED z?(=J`H@)Rj{uD~Z8cGQNUF5HKj@LfstNAyF_!js|0&Z06yoLBwO^wmU53&b@jR^YI z+6!hD-W%C53flX(n%#ILWb7>H`poVfb;2RE1rD{oKHK;IwY`< zLt;B#$N#^DIea32q6s=z!P1$}J%M0yvfmhp*YU6Lv-QnXq!!3m^hussAivQ1xE}$I z%bxNmpkn@~;i}j%_K-y~5H2Q)mqFxOF4`<0wwV&mS3rA{fyx_q zZs$F)ch##KeIa3}v$kh06du-(8fQT+Haf}~U~z?=wtNb$s*G4)DIA*m_wH79Fqm3f z&M23__}1vo+kmN5#lMtahy)QXn$ZJ{RL>dDd!X$vu;c`TEN^5PKLCML6;pg`m%N#a zQf?K+f!A=_@ECZG7R*X~64bH&agkOqmk)k1b{v3wT^37A{k88O@6jt>$4lI%RAw^J zhCDF>^y5W}=Qy|)T{}=X0gC+2e3dr}9Cx1&&pQw9a;aS$W5AP_bDMiL$er3{V-m=o zx=mgMdBu21eh#?E#15jjqH+nu7iur13WxwxUy%dq_Rxlw;b2)29pHBu{3=&32z~(k zYu4!#dJSwnDjx{k0qWGiO6GMyGK)A3@^fRQd=l`G>ys4z?;&CXw@e4>iqDlPKrZ8i zzxVH~^qq&;TYX7Nx!z82q^!p_PzEaxh)d95c;|~z{UC5acm>N`_%7;Q=cNsh6?1NF zK^!=jvYP2|Ez$YD<^=s~tId=Q;hW8Vsu^60r?&0}V}wj|SBJnzYX$Q|VCtwS%IhF^ zahXJrx_C(RgTO8BO`flySzh`(d2`^%tfSTTdI8Qt}D1ju)BVe7*5^V|?FJ=pqqvn0l+;XspTaHx^grjd)7Nf63wo(Y_j= zcYId8icbvsA&kHDhw zg~wZaEXe`1>nWvP68_M+SK z-UOq*w$+saRG_bz2$a_Pm-656Cr)$+ImKwM4+ia-oW+-Vfbopht*9r6vZ9Yz;#;@m zz3~2TBpL>YmLh>6AjT+fiN&Bjm-U=WLeAzb`;x4XxM=?IlkY>qck>=NIRw(xmG@j) z0|m(k$y^97HKCC`8uTG{lXeD-Rqlt4B#;w~`7#`^bAoKZLmqCBvy9U;0AsUzlOaK0 zR@6Z63GSImQAJ0g@V&!1S)W2i!l&AmKuDlMBgjES-?S3&bPddg6UKkKZi^@g;i3~zDMs51xH;=+=-x#(;qZ0gJ|s&3pD$>L1|)==mP;o+9RGHpjmACfxKXdl?5)x z9N;QY2Hc-BLCpc}1$wH}0UH7x#7UA>&15krhMSFL&o2Dc1pDYN(O(&D!UTJ4Q(^rUK8X?a$hvq zYdcN8;bZ2T+4i4;;++wY&&n0@AgDQtRTRPKsNU~2S`A~>A)~wY1g(&Vtq;J(s3c4F z5Xc^tSH55boZELcVv_W+k^|s!X!&Pcs7Zbm2e0Z@xsm0!yourG1l;eHZatvsXkDBxR?$b{^dv;lfki0|mS%d-?*`Nre&Fc?#f z7V;U0h_2Zys5{)&XQSPle;HG~0HVh8|Cgkk|q zgkS-zRKOny5T6qUgo}g308PblaTMsU>=z!OsW>K%f;^|Sm+L{>oYBVF8SK4J9LRYZ z3cDSvlJx}`tz6ZOO<>tnc7b08sOS9anmz?Fm>#qN9^-Bb@Md-h;2B?ye?C2BbC6EY zy?Kp+7V@0uDqtpDe0QraRw@5NaSi(;{0+)K|)b(T=jBB2dQH&FMdBXcW)b_u_W(1L%wNS$ZzyJ(_3a9fZK=0zL|S z6Z9dtO&MV6X;#dyLUniLH_8ow^5;X(n^WQY+#kEgzXR>EzikBazSRxavX)*C$~9QtvyUn8~sAhyTRPY@B5HRaB)V`E7`%2os+-c z-VQFx3)|0EhqU2o^->=M9^@f01qdR@*N64yxQt2}uxw$kxQ~Npp!)s5H2Q&mw{JIyUh*|Wi9vn^#t*)X`p!;7{|q0 z#SM<(JY=2-+H>Mf)dUgsozG}1pjqdPBYB%4LUAs2KMXQP+$*{Qg_tpcXhUVngWl4Z zYHWnUWcMa53EZ)s5xN`X{ahj&vcA^V=*J-8N#`JKEO=g(87u*#tvoEZL)m?er-Z!$ zz1uzoKRNvH)A%6(1%HBpc5=FL4d|~NSDplM zUa_hBfn0LQ1#u2LP7wLHX$77`v{pU=dZUUJc#En3TgF@Qb3Byc;yifTc;3`(P# z5F06JZ3AzZpbT&7wH1B+vo`nfTF2+U6)e60fPPb3FXeZmbT05u<_5?Ah5$@2-vctu zC$6Cs$HaV@0VU{q`34(fhwNq~KoECB@JP57^roNin7qZp- z?M1P0_4O+=u4F(;pX7xpw*fV%C29fTL|ktdbTi~2@CQ+wT-gmQkFZI91sH?IZoq~3 zw;2RF*`$DIA=)YHK&&@Mn%@E@t20ewKzwNmw9E(5!dlLMGbrt?ZT*u#tWX!4?gL{r zk>UYx^x|Rj4AAZpZ>jG?M5?o?HW`|2OOMHY1H$V%XSlxv87any?tlXmDv0(}AqG5~ zjoQW&P%zz9q%{I}k>^Fd5*VNIImaN)&wavkJ0vV~-lIJLo>$~3s(?I998I87$F}!J zO@cl&?l49YI7bliU?7(?{8WK)nCB;%x1)UTA^js#Io^kg&`{_ZMB{)U8=ATP=VG7PVnWcaN<(4XORl*MhL zDi4A2koyJWWyo6f^~i*~A?fU^!Kaph{kdZwXNQ5DW2kflW-8fY8xTMpLI4+e75kxqz86*no-3XW~QPEO)aD ziaMO#m$wI!pIdbN%qqxqteJRiGwAb+u6pW#7^Y0*Mc;XG0VcxefOiJABi_-$^9#>$ zDYqV9si3jT=*Pog8y~PueHyy77}cY)6`DOVyj-Q_palC}HgyL1mN8l051EtQkLzn7 zKG2!zsR`~;a-pmP`s2oA`56?v;1cfE;C|RMST6#Cuwns%yzfb}jTj`_fHhnXGjgEO z*v!HC)gkWNe7~Y-kl`E?N5MIs7cIj<8%P!PFo-wQJd+Nhl{LYCA~3?M{*T6Gjsu|m zQzlWdSYWz*S`Gx+$CIdy0#f9|vOQkSiU59UCtZ>6^$DOxa#{uh=TUrtg`4~JD=rP# z%Mao(6jUqNRj>@sw>+DB_AbcVpI@ag4XzAI@#H3gqmpN-*Z@QBy8Y$02#!$>N4{(ks<#r?vB1rC8+LeS`RUDSr|r$D#atQC#cqi+ELO z<+XEsb7Gvpn_(h+m$b zSuhgP59DAEh2+4b&PjQYaDV(W*J^=GmY0q5Kwawj+U(uz5b9m)5(;I&)Q(ez9hC1m zZ?wm&1yGj%JWC{TU^$((760cD)6c0fH4Ev;q!HiKAaN;D4y+KFXiALveO zVjDPum}OZ3+Fg7K6QPhYO9OP5m0?}F-`A(4CJU>Obi;-Y%_dq8$Dj_N@`0F_1k z-@KPn{_Y4A%y|38`-8_(&?e~s$T)XY;du}h#1OIWRv#okIsSJjBX|ztpZ;>aYkf2^v)6_IDZ?SE( zZ3N2~flULOg1Jv{aBwiFdqet#^aCY3WI@ORV1LLzLjD1=cj%bVF(BK8-WPfwFehYs z$aD}pLSGMk9n@u^gF**^IWD+&aBr||2z)s3VK67ys@kf88ftEDZVw_xv=ZL8kdvGQ zj?2~ZGr&VIMZi3zsW=6CEBlMur;z#4=h0W&KcV7_W6>qm57YTe0 zxJhH}&#rGNe@!g-p@J-L9APO~GOgW};n1F8Gh_Xs{fpxpRCyarOM-itD zySmm)kA-V5IOb@n;0iVx%RDfg#(J3mg~wcV+#|qs#N+UM253I9=TKkQfL`Ku(Htzj z^sz=AXt*%z^Zfgu%87iXC=8^=DRCa0Lz!nD1KKK@s9iw}P<2x?PzKq$_$LF4Ory-p z0h1^z;s6hcc%|yR-APPDQwdmQxb#*a56I0%2fQVt<$+w^gi|-n$eO6yOuqiZ38LKYKz}Gq}|FqU+)q$n9E?Rulo3Qj*hiTZ4!)F9_%cU?D%(N+C~fot63L+OR^KH5!j0Mh4|~ldUnqCLt{c{urP=_0E~O;^e-g#& zm%jh{B42*3z4oOqytdb!H+-z*IR3@z{$q?EWKW2+g^acJhS^ufimp#VtJ|8jY`7g# zhv$xSI3Qt8+Ov7fA^p=dk$wy=j5^=+{6_Goo@?5jcvJqTax)@-|BUnvD#1vcV10%! z^o?K&rOk#;x351Ch5d=hwH^r+!9$937HjkFdA#mQ$3`?f3 z#y<=q>N}s+RzS16)4S%bgRnbYsul&(PfQR!0mD1Miw;yF7PKFYPmM4rOm*eD>wqUx zpJbc|;~O5~OGs|#3h|tQv>xtVo=zao8HeRlAlsX&DK4njqyL5qb)l5`^aqv?ZLusIqQHjvX3zuuo87$tgVz1Pl+o5 zxRF4riSI!+GIF#wpsX~#XUhQ9<)0dP6qv!?c$-Z9xgwJWE_4w6l^*;9^ey?1Yu6yH z{D&1T?S$O<-_%JS0P-&5NBKBVQRysd19o{>9tY7u@l*W3bip#fG5}1={qFR;6GXg! zk$(|r>-={3?SO*2&1cMKAae_iX$;A=v~k)vxc0g0ao6Jze}}V-vkY9^WOv$~aH)G? zufkq%rMbP4y%8jsoL@P=g47FIh!z6rl|5;mG{`&7HLii9jOnE5B|{DVXk$SUrqbEW|8WR|BqU?NOxzlHZ#DZdS$Xdrb6f$6 zlV||ir&bqC0Nw1U>UkDic6m3if^(DcfsBHHDQc_|4{DUqsSa90 zy}a>0L4Ymi004jhNklFRicN<;h{ZKZo%!=@Lp?*|cbfgnbxh`~0I0%V7 zGe0R93d#u~#D|o$l7M2r$0uHH4ffi4KL2LBFLaT0*ted)uOvXb*&USf>nM48lK;>6 z_qG1TjGE)MBf9$jaO#HjZheM^>a87@jpR7_G1v}TmaAXGgwX?PH+vMiOltE*lgW_# zl>M4#7sTJ5dNgk#tXKj5u8>d!B)4^{Et0_u>*Wsp{aSO)Go3^eTlcRhxhUjIqeKkTem+^^}I8E@vL zLzvk$L$mrE{~rA0_;;i#F`zBeUoxCf*w!`M9R;2?#sR|x`Y1Vqk0H64tFN{P(i>{k z^v6NYGrp0J1F@FJ)fi}0f6zTKe$cVO@CmWAz;eQ`vf3AnAB}B1!S%>|DW&|b2ozMH zhy>1qUf+4v-V|h6eUxV=5KJxM>-PI!N2%gM92+&!K!k{nxB)9w@Zc5Q^wv0gf9y4~ zP(a%G0Sizd_hA7%WS4-^u#`UF$T$bI$AY+5f}$zW3T|T`T#KT@I5qU6~imQ%c;Xd%?3c;v~A~ z35l?>Ub9{c96C(fPDAc<@=(kM)2onA0<^++-EqPsrNDT{|%159shkmUB;CLA`E zWvXQ=*zwNd@gnY>f|9M0U+1gJ@Kt!#v!P2L3Zy0JV?KIfx#!yG;25IFOv@+{6^W|I zvDCieldph6sxqvdw$K?Qt>lPHl$U3a;$&J8KyLQ8LIiiswC(Zm$H;n=BIkiOhURtxY!eK!4_)EkGpJPzVuznv z-;P`jTN!KVGHT-r(?y6L`;tW%CzUW^&4;7(GCOs*6cCA{95@=8mYg~ z2UJHXFYz@9{%W7K2FKZA_Qxj=5A?x-lRA%G z^2XU-uTs}GtjE|4MPE;l+T#R+kT$T%RePY32l?zF-vjngj@1EX6(teBQ*MEj=;TY#-0teZi`#(Qa|voB2ngIKHw>)MuPM+sy2I;&sJQ>a0bIt=9{mj*uqwc)z2CLEL`Rab-K! z;pucu3GNm-k=H)dHV^*FZOgg)(M)<#d0xU~A876}ig8Lc&~)@(X0iXKXFHf{s_nafz&sCAMF+v-`Jw|bClbv_^MGVuRqwv+l z=YM~iXm)(jnld8FWYiu0UAvsSfSU}WYMDBeLvF?>PGqH z?_omxBOu38xo}}7WccqBiqHK121MIHZZheB8--S6V2l9tI#DhKZ3= zLm0OUodg8&71l~i|2X6n<;Et&UdXPKW{@@NP`{?>v8#DO!G8T*IYG?k@BPOT%}UTb z3Jy`)G-8LuKtcA0et=a07i5c&E+Ve>!hBNPtGHI96(m{b!3Y)@^42jAHFG;wYr%BN z7pQ~Fx|_r)-2Tg>6?U{_kAE0P9(!&9@x6~U+s#_JwkYk1dT7k?${BMjQNz_=ns%`0 zNFyCKL@ClshV_HCC9InA+l+O*4+GGR?PBq<_i(JdT>%lljCRHO{_oJl@vtAHdVZ7d zC+f|=PnATE_LrwmnEaJD5xxVYETZr)wzqF+rPh<~X`XVQh2ht2%?2}`SR6EpTB!{v z@rx!{zjJUj-Wg>3Hj(R!dESn1qeGodOB6u+$~h?Qw$EbV7&q1w)i$|NG~%l0&iE(UG!!;k{n0&(2&{n#GC26oRtks8euUBKAITs|5jWs z@(eJ2TPfs3O|vLV{3+qXvR=as);^}bg)hS`^jnTqwqGNfmA(=nyy5lcsD|C2_HRp1nwBSIdIaw(10Zb2_a8$1asrUlN$~-|ql}A7df_k7u`9hn%z!s}zqA!_Csgul&$WnwMEt zB%QNnFXJfAC0%r0$v+YAsyAW8)u`;#ubzlpaN5l#p=9z z!7?=uFuTxv#^LJ{JO?J8{iN}b*mwemj!T?%)?0>t1eS}Wgr!on4f1P2i($}|y6gUH z_)kIWX{68e1~{mT`Oef^zTG`y4t3^1#ljY}SX_rle-Azc4<27;AIMybYP9XK2ut;( z4^+fGBiAF||L8T1btZU`tX%hgJGq>BtdNhC@K9;` z_zGl--olO7fdns0U#Gz9Xd1E({c^fkcG|xE+5nonMacKi%Zv?pP+VTWS>rliyL?~y z*psq>ueH$7s=2i>TlkRC%KWcSOiOkY5gYLYX6rW`EekjJ;s!fb(Yvb0@h9xa+#Ic3 zKO0VT6gq|tX8q3kH2Z7e+Jv`<$FMfHEDUT(FV`A+J$gNwx@Yp@3V~_+8-x_bh!LmHDAB}UQzgq$JlkDAe;1jG0E63fHI}(^FQ;0_biDbVXe2&;KM=NMFtM5T z{9F0rJ@IDBL2|4#K%D|uh zP!E`!hO8p#*1b_G97dU=IIXnS>&o_f_1lS(vM=qapr!L%arKiaL)Em!JNn#jVGPto z%YxTX+z_X`9%lQ(p^)729bOAR%Hc`r00By-Auz!1Sm(8by8@n(*nq+<*)vC-#x=6hTX>A&Istbic_-vnWLM(o58OODkU^8nC}b-bi=SZ$c2QgEu{5)uj_7ruaZDYa+Pq7JhA^XD%_^-&<&?3suKL-K47?M2qd! zD=eE^(tYA~Ge-Gq;?Sn&YGc=HOjIgWmoW2n|7YIv?SMc4Bdjij$PSYgaTBOfsNV)s z(dnRUuYa2v)v?U7X${Z$grC%mz${17n7x-IR60IcG>>?f`k|Ng1_b=^Ap7B4Wd}jK zb`k~U^WLrgy%|wu`O0cTYvb&iXF|sFCR4?wpGrjnV<)cyGvqgyopHxW0jlBrxLDiU z%)o%1qor-5#xqqXhf(Q)_VhNk2Aa&D*^fIH+72@grY)mD&hvEltem^7C&zwvA9MIR za3LK)+Xk+60!FE;s-MBs86|a*SPY4U{VkxlVLhEVBCi%zNZ6JxuD^DT7wOHCAfMCD zR*CPpQ*RNTel5cMz8Q)vjmh!}=OVdJ)tH`;|4Y)`UBJ%l5P6)q%4Ovr@=Duht*_5> zecnP;)5yT$0!j-$QURMugEXPQ z7s#+b*-dDCKi2r28MdniBD0pAW0!p3u&y}ZlG-66QtG3Sp^IBNUZKBcUOa9sKKXB0 ztz0)w5fc6FBc;tB%=o)-rPFn6E)(#Gj2Lq#-=n-EsffuglhAsUkU`f4Ph&r$X(@7U z6s}+|7nd!justvGOUvjE8&{k|z|GRI^phzsAVT?+5yN7b@)!1pid(ggNW(?ED)ACZ zt^{;K>vzxfX#$m-@S%fT z#B;s$pcBy%sz`Y6{O-W~S5>GzX0lwMo;U3V8~)$pP?$Q(%2UG%@xFG7z7x-<@!zrw zj>I7Gr?$o7K>>ah8uLJNU##h?LCKFnCHF@`3!=q>uI-LLa}MA9LDfWmb<#l7zE7HE%Eu(<);xi>!hpKBZoVk4Dkp{E{Ahg}WF2z6>A~52;3vQZPz1 zHk|%ZvjGyygj5r`PrCJM$BMnXi}8`igd$*uoGsfNOl6AgAirU|k;I zST*D4d1EB;tEN)T;Iq`?lv-=y+(&1kwegex8=)+%yMy`?9>4IHach$x5scC~XX&2p zMiKPwS9=$Ah zXN3^c-)FJ70d-HcbvBW{Taqcx`G&2M-q!PBJdiKdOv^)c1||N16xy$ZU%qo*(1}q(A$E)SO#x*YsbeX=UaGdtkZi~7 za;5;`!|$o%Qo5#lI}B9Wt3H;V=na`bI3tgz8(?qW{~5Oz}>ORz2iqYm5czcA+btO!+)^gk6f!I8|t{oh;V3x}B~1zcPPXe5f-dFPv81 zht=u-IsJ1A5&Hei_dEw{ACwh%E97bE0c%*7V3DCDDGVvlG{6aOyVL^u$`Wtc% z+ZkXN%oSWNuZ3tdVk`RKcg&t5QGRGUQTxnkfu~~ZWvExQB6gK(041F>A!rZ8-|kC1 zOCauan1~@A&za&J;E&}IrynQ7cp|IUn5ltqi#(`V(=^_#{=PqN{!9}tCFjA0Yl%cir(UGNo@FZ zsGy*P5jN@Cg+{&V5S{gOs8UK3qcxED{BbC&APZKn+sEJO{OG}&X0H>$`Ew7QIw2-t z#;)A>5b&kg&A>-M+K)=_4GVsWMid#PGF~^!odNOE`eWnRtgmq>@>rR66DL;fuE=&2 z9b~8nYa%Ph*H0crzykbF`){4wom26o*IjZ-GSY+WlltG74n_gNCjr&-FV|oCvK@9_ zqFR|0Gh-SD9b=?SS#V=p8{ZpIu3p|&$=y(BqmQOy4^mj=i+*^FwdKl6`nR@w##O_J zqXTClp(de506;O%R)1Ho<%AOJ_e0Rwkd-JL#Gt_+r;_Wskck&8n(Nu$3c5#vP_KR_ zaG2k{nJZ+AgBqJ;mtkE!RfMkC2ME8c2>N7EMBbz5a+Z7KdlR&_jlwH$2)E4p1f2N8 zIO^RxRoi#&T<~mY7h(J2uWSCKye~C_t4zEnUj7z zyk%R}kmpXdLP7|#%Hm@Vx*6df!rGLOc+jQ`rFo@b3oNda#M0@cN(>O6uwT!GhYzN4 zjd4)&a356w*+G-M7-o~wag}fZ%qqr>lNbvr^uAlyCY!q z@0jg=7Y~~=CZ+=)EM^-YcFr>LehX}8vtP4GPoLy$h$C;cQ2s&ld$6zP z93PO|mYJZ82pId`n1hnSp7)~=h3iwR^tqq*nmo0u3s-~c2px@0`S9tW5Etf@PCiep zEY4z%!^4jUo(QUEynONMT=DXpq;gu*&$3l-upS6(Ig3o8t@eBRLmJS+y|p1lxKO2j z+j>K8i}e}R46a0H8OHWw4*0KqVjKbOv(}j0CaG@5;c{VcfLA0Xb6}_Yiu)(KknX^W z^hK`m{r!f67KvKgXbi-kFMFm$l@`v43ll3}sMEc(g;@NEZw}80_xKR%MqIWpya%D~ z=cfnqPF;P%^RBw3y3R{d-MftqOp@W)Ym=w8;GuPG>HVFz(&I>qMVp6=lW_Zy@ zPZk+D-EG~gOV?XJKk9h&tZF|K)WmyJO44AHT6tg0s7p34WV4s&*(Wp%0 zTluC6ulb5I@mq1@ZIPEiUNV%KkXY1hs1VUVoNHxvpl+7P@~)IcRrcZ8D_FDRI#prcwSU z*7e;ieT9t!r3=b|;}3sChU{hCkNXc7g=|HYVIQ!-m)Od|pL5$->9-zZpChcl;(^dZ zF|#3hz~%LYyoE*Rp!sBdwB%&p7| zCABZHe_!C<*AXr#iA8$cm@zOLJ7fB*J3j`x8K`DJ!jGa9y4?Sj&9Hz@8WSp^A191Z zZBn*F!DF(DTr_N6@?Q3)9F}_N$<6^ft2-Du(1kUQW9L!8hOo5=YtS$jk)kmvQMIT$ zDj(Vdwn)$U&-oi?RkXg9`ImAQf1G~pz$e)z)dt3Yo7R`!C%Gs%YP3xN;Z);O&!1*yXaZdf#v-D#qW?KCx=t%PqDjr4mq=)gA=)SYWYpr zJ<=02ez5!CO-;xpDGpCx(Xkz{PjAuAixHa1FLFiEZth6&vw4HH*}rXltM(sNE|D3p zvpUKhvtG|;C#MUaj64e*C=&7cjZLgr@rl(RH7F>^u^`SAGQDW4nC z(5I9<>0yXEk0^EuI1wmu+n?oD^r zpLM?xevPj|C&H33+Weq|tv8u~G-(h{EV?YkYgkexxoHq(sNFY4>@s!ihskdg^XUOL z7PSd6u&38bRGad0VUG3VD1o~k9?CeVD@MEm*#X^~70ruiC$&5kfYxje^RwCRB<++Y z5$rQ7LOZ8_f!4s{hHW2UeYyXNq+;iHL<{w?H{*1Q+SNNTv^#TI9r~n$jWvd-4ZMlT~#&!Re((DgaxGY${*-4Kcqw?GVga~@{}JX zu6u4ImYUo+!it}My87Y{I?SGPZus^VKlyfF1+zf!&cjm59b;V!1t9PTKXFT)(!t3| z#KCpuF(pe@@6a?dcbI?$Ah^={+gIUrBc~%frH_J6Y@6J3nu6!j_5CZj@#5^d1%4Q} zfh#3{5OfXZfi4I~MNbFVI`z4bGLpm>HgiH`BQGQ>fsdhgg>*QY!{cS17hbcvVJ+mX zQ@rS9)(V$Fz&Rvit z6g6W+I2@E%LYG-}nRU5_0bT`OuL*t1R`OPW(G7KaiyRJqh8Ns-fS5s=?U+tpd+Zt> zDa*oI@RE#55HskZA?=uJ4fy2z@i=`oxQfM>=#fQo&(d1lS{$uoO1n!NDEa(nZK2~0 zlE^F1h-|}(_0#K{K;6x|@k`o0vylp+PSVoCg9HBpI+!Y8?&c<8Uo-|Y0M%D4cdp4ZEzxn;+ z=oorwb%pYa<^r^7*@W4H7T13WxqF|hx{3%fP&=?%#g$rg6*Kc9SrnVetuUobwJtd| zA}19eJnI2J%|9JD8+|LY0G(+Wr?-=ue6%&4u!enkNc*F+`@s3!OsDEnC_)-u!FUm8 z_H(XD7owmEtgPue9LE}WUmD6 zNd1o52Y0?c{Vx4Z63#BqD9;Gh5P3}vj`jlMJpWY9ySWwWU*Q2qd{VleYeqcn+m@Q( z6sbMx6H~$T<8c#^&oC?-Va2ae!cjZzleYDgQ8d}C9RvoDCcURP{Q3<#;(vWDeo{Ix zfBt>iVU+PrR`Mn*?;TqP;0he?9C2!!_qF5m&rO!CDk)&Jwo8 zBBd@!9-TVm&>VbrY3!mRA_b=l%7+Ut|7M64(iTNQgMajK`P9RSGwz_udCNKed#dQUa!uuSP!9g+ z7~5969^@>-^ey;fYp4Ls>tM-+_`a|`9uelDe;?ygDSC8(AL}uOeUOr=aDcD)yR}%J zs~rGyr2k4+`B!zwT0CQ~E>6XJDAK-1hsNS`1hS`sm2t}Max~p&{=@Yoe)~^XV6^1= z{`gQ_=fYU!m*HmA$p&-t-Dg1IY^IIF2Ks;pDnoV4+fI#MHt2-)eC=%KbZSpK`n^xNjHn zKz7mPG=-!$U!h(p>i?u45h>MKI{=*uyQWG^83@nmDu?s+>5ieHLY%D1^gLc8N5kk;}b;*$6H}$(a>kY2HL* zQD3ro=d#pa&UTbCO;?6~wrBd2Q^ zEH@-CZ~NYcboXhuVbs3MqAX{&5}@-{;4g4i-SOBfJ1{I1_1ZZRtfF}%I!Uvo-W1B> zuF@sH)9B`W{mX9>P-IY0vVhDZ=lW7nlob8FyYJ^cg&<8Ra=n`NAEU+^&L7`)-@|vp zg?n7#HiK5DKzM>C;H;WnV&``s4?32gP{uFFTj7(4GnQp~PnU}p+&=rG4vuwwwB`}} z01Mnc8M1dGhPO1E^FrAP2vhy}^BGFR6?HSi6+Ni)Htp&I(e5V4HZ3>J^7f}$VyYl( z`fNStGJcDUsU;ydU|^!e#$N-+d>@u)BjQ5~R5G2mx@Yqkv+^Nr)KPirU&e^0@@6?b zB(z@KMe+rq?I==6kLRJcF zUnRASLULBQRJ&9Q^WvYTvOwc~s)6(766LmeB6-Dc`I>#(Er0%$=Jg!}e5d;uZ*%@r^*P7vA(HCZTnIR+IN_(3 z!)f@kn5uqf zrz^M7J%ZYh%v`%11qK(lt}z9Nc`K`b2Qa>8An0-6hzH&6c6VtDrct#s7l~!&5R@Rh zqBJ37Re}4lA8FyAd|v+{VDOG!ID21pQ7vNWgSm6Auz()CRPuO6HYZMFWti!oZy8l)O)XqsANVMIXhB-0 zWH>kD@V}vaHkunDp}=fevKIFlw{B@TWABjY*&sH$ED$3zGmb6;R1*!gk~9MK^`7O* zfmC^artfCoUjCV^-lB09hJ8AS!noyVyy?1S9L<0}wcKEyIwP0{;V5YItZqt<2JV^G zZL>G-nQ9F0YGA3`Tbii~fBv;S+7T!&!8?Ng&5w+WI(t{LBz5j!6qQ{eli7Ix%0M75 zai&YL;UIZ)&Q1a;`!nM_)#MJ6JUUnj@*8A1>Sg^6Y;__$fhH6lyO*%e=fdu63iG?e z4LZFp<(Z%A75?@r1lf)*{xgLf%j$w;qlqKYv)RD0pCLJvxF6aDIhzrJop2UFmnQsX zyQ_2~j;Hq?Wc>YiQzohqqQZ$L=#^Hs24a=jk^bT5=bl_`ZMZYHVqwTr{>W`UTH@pL+^)_whIl53$#@+d2v{ma&5q9kDc{h^*|GqBY{ashvBM zMx+);;h(=$KqmiqO_KPld1MQ91A{#bS*PaKaY`0#-pb?G0|f1-yPgP6kJl1vM8me? zEq&uo(LvHHL2v#NpD-$XF)XW%Ykn?+qfIPG)IF~4^|cPOo%mwv+Zy5^7t96xbhOJv zlrcUF9Oc7q8cg(n#Yon_afO{)Z70Q}sgW^mlUZdU5IzuQHT(V{rZw>f=QHJLLyVxVrC|@EA-H4v1FQ5jy#K( zp_sxU`uvOy9;j`EuwP=}ey#cM2A5dW5~IE(d!+AvywP$e{-GYyKCv+R2$G8=Wp4(P zzgEo^+YUo=3)!`8qb0<4VYKLi<|JTl8&$c@mXi60Xx~p*@ef#;KZs-3Y zruLAW5B)7C)k=et)QK1WI?fj+QgQMn_W*+z`u(Q-VTV4s;rwjT%X@1TJIm}G#fqKp zCd1J%3lO)-DSo*!x7;4Q^pDR$=NR!ZnV2^Sv;Le>c|3~5{F*-5g#GUoXT?O!$8k4^gb;0J+@ZOJQLS!3cSm`H5Vxq z2pR5g-!oPM`j|aE%0f@Re^Q%9IxFI^3OtQ{YJPg#NU`fWbcphFyk~n^4`~@#nOh-Y zSvDh52kO=qXsW4N)77T5S6r_Wx6ARV%DciR7w@g zLG%-Hy!aBT5F+W|9NYQBnQVA^n2R#rh4i;Jg&?Bc25F&m*f;r^V}Zg>+mv+s+Irv$ zeU>-4ed5-j8ec}wF!A%53Ao`mgdVFWkWTe0`0wk4Hv*@@k(WCoL7#yd-h&eTE?n7P zu&2#Irb%8sy6X+?^tT^?VdrM;NTXHWHn*gpoD(bE6EX1<@BoeGkoG!;458!s{&UA& zz-4RKU_au zPq1OU)+bsVS-?sJGD#**ZeM8#8wZ2)upbq(HBs`Yw|4`3p** zU&J9p9ahlVU*`v!3!x{Oj`35@zPTq&UwUx{yq-2AV*hcu<0rGUEI2P~WrR8^PV3X> z$(b{#_*7;egPidC>R&D7op*_K8+u`HE$j-^k#>z2-Le^BX^cA&8eIl;-o}f#BGRZ6 zgj>=R%G2NjexIaj0&>@(bX7QRCU=3Wm5N-7FRu1oAgsMRrBlfsiQ#}<{?6Cl?Y!*< zc$U1|meN94an<5v3@$#e0=$X(HeV>m7oYRacFA)V`7i|=} z>bA+}`OBK-?Vq|qg|)K{6VdZ>F~gdHe&AUIRsrL(@Aoe*b%nXlwMPwgMVMC@+7J!e z)4Hhn2eVi=H~p0djrINYp^uz%ptd%#o+*;~0eH16!{5ZNXw+{g_mPZI-pte3AK?9?O30~%b6j}_l^(~;?cG9P_>{i*Lhg` zk83lbEtluMog&Q9u?pAAR@~*{pokTO1QHA6-$!6F-xjYBcCDVwP-HTg-G}AgSlWJq zA`yVc^iq{!tqE4RT39=1yyi-uh&?z~_)^dvlQL!feGbqspAF6i8)p4DQgxGT6Ejsz z7DA8v`p|G=4_vrM={K&m_v(FiI~B?ar2L#IFdFDuTjZncwNAz1h+Y+blz%@aM#F)! zf#i`w-2-F#*X-B)17+T>aH>}a%JrduTB8G4DnBrmH zDlJivvwpr*Su$|@F4Yot$DC~6m28>C6d<9P5IOKHuyp!@zCzZL@AxH(s`)BMU=gTp z8sAI|%Wf_PAU1}O?n3c6GXm6^H`#YZ3_DswC`iwQzh;R426&wyD1Uj*f|S%1b%#VJ{03jI ze%#q3QOEv#*`-cdsh%m6TYH_)z_%ji5*{BHIK+aJ-=ONUJc9@=Z$H-2{BfU8uM4Lh ze@BYB6&NeB;Gr%Lm}<)hT0&fZ*UGJ+$W&TV)Lu(izHlEx3@NO|Y~v9f8k9P-L~h~H zkl1f+M?zTGIwm{2oFT`IvJ`pBaEEcHhGGH-wTg9N7^m`^E%6s?t3OP1e+uyF-S^gH z5mL$8*w?gyow{=usm0t#wwQvZZ5WsOl|H$5$f@I&hLVv9CpMv`jP3XMnbk+{J*mT1 zHq;y$#lwSFwe3<354Ty{t{6dv!I z7q7rRLq2){I~!DY%#$Av2c=Q`vTvu!bx+|pZ6_v8r;J{+fdd~+=>|swhd#d#b&`dt zhql67$T$cy4V*dfoyN8^hi(byM>&+)s9g?dZu~;8i#Q0P#KVfQHZZ2)=QaO0CCe+F zcIF8rJd!kS@%N+%X<=`S!caC@jU!Hp2<;p=U9XXqG`^+iqAz|sE29LRvS&)wp1~a? z#my)I9uosEj1;^BppCvCxG}UtXHM(?7 z#Bz}WE@QXzKjBT<4P~wm0uHE$m>E!pn{UJLu@Vbk&oxpjb5;{xkJ!lwm349{2SVqs z{?!RkmVVZM$g9m9av%Jx8- zRkx-`y>Aye&YmOH)Q#A&;*2$h3ymqwUC-r++h^2EZri;LFkTFHN)H+iv^HBhM*8a{ zutAU;&-G-B9z*8$;Qzs>bRHuSue8?+X4DteU|WRTBY7Ov!Znpt0S&oV?L|$HK*_z; zhb(stvxt%nY09zIDAg(jO^*iC2Gc@8J-XZ^BJV@YEFch*+r=}!p!-|3>rx!mlX|UR z+Znfwj`zLq1AWEby;ig#S@M^wmMpu$HOJ4bL1VzhDm2bLL3l4XjAJ}pO$#0<`{x-^ zn*#(+{eBoI$8nAlpjXf@3M~*X2a3}CW;JXsID-E>*(s}=x9;Y%Ui4_Ac7G664niBAwX~-Nn&*7XhR1(#vY^q|#LK zq>{9up}!+~o-@XT-{+&EMV^H-BP;w0aO-seRBJQalLJHsnc7>zH{s}gprSMM1!^bz zwN=3%%#FLR?O3%zSQ;48;~#ByIipFp+4-uXc^FdhbN8&v^JXCtpO)`e?j@+Nl2@71 zi~{EY+eQHuD0;!E?Oh)OGXf^xvk?p-P6;1W{k;hOC2{iLE7;3!6>&<&wx#{@q+w!L zNRX!E3Y3^zEBSDH-lV*2AMLAL@1J-}1{{T-DAly>IX}D{z5={qV!h~wuPek~IjB55 zO-5@D&TI&(Vv% z9t*$C0)yzN-fs)ZihZD1MUyJ=ZB1({$(Ae&KC&ufJUlkRr0gF~u=O&HwXnp&cQ?Lz zM0@J{vcRpc6)s~q12JcYt=KhRCzMA4&o@qM_qL%N$>=&I`XMzsto_JrpiM3MG~Wk% z$Bs437j&9qNr!=+PP!*vzJN@-?bo1MUoG6G8t)B%wI|6#F#9Tvd$rQPZ=(PFXm6u_ zqP9LP#I-KRKy6Kx<@Ev4U?Rd0As}OL`^E zEi2_ZfRJj2_haBggC27Q;rJc-LDUy0bpcWN&CDC5GjOysWx$m-jwTM`QfBJ))azKK zp^6&T)Es4j5(-+2dV%0{G=t8Kn2flS=F9RRC_3ePbB>ID|ASvau2x84PlKc$Pb8UR z_z`;%frGJ0>EeTEp+TOOd@fXpBSxg6o$h@vgA;%D->kdTP0c831h&d}M4l1*lhVqD z;dK~ws5P<~(KZ-J$QuJ*{gd;0hl}JGgZ6#j?>09a$^yt4a53g|_$0>G2ILjTJH@=R zC;p@9f7yql5BR%V{d>V(hWc67Ugk{H9x!qjv8ZT^`X%}uN4PGiPFt2bMg%9R9nFXH zLbT{ypHLb0RUa>fj>F%wq()y0_slC^?v6;9gS8KW)HfI1Xq2758jX-aukikAfzvah#FFyC3y=N{S374}v zY?nJ85P5iBzNjjxEw0ODz*{}13c{U$vy$PYEChS|^-%nsu;C48ljgKo6FV9xlbny$ zi0>(MFe%8SX>YJG5acfUajX<8+5Ooo;FDo@LLk8si6pzc486!p67Q>>EXN!psXUs% zjoysU3XuBhcUbxhJ@sgk-~TzgV?t?V(b*+V$FS4QW_v!M7`6GCE60X#jR@WM$yEPD0JN{RP!L-$i#jf zya#3cOJO41did2&Cbvgp(;##Icy3^c2j~=Azck6DFbw07<-J?*6p(LJYCRTf zlCVScY~Sv9zoEQ?n(7U{6`bZabse-3BujSXKBSvRwOX@SL!?TXzkSXZ^}wy5r#S%z zeXLEYPV&FwO#aQ8fUCwB`Vlt+=kl1<`NuF(*z!@wj34WOop;YWzrCdM?8@{F%$iR3 zetnr~|NQX&l2l`f=;?#7c0|&k-?j%b_q!;1(oDBz)**gFzkbVv;7%UyNC>2wPQ54K z=94#bJJM-@yF@EsL+!N0{Zimx!~X-rKs>*!2uB6uZuu>z!9BvWRz3v2u&tb3iQp16!}Z7G>sBCNVjug!>M=cRdKfCU3P}t} zgj&lZUWj-BDtLnW1oZ*)3Z<9Q3*<6iJHuZq5@w?cW{^!i>*XuJXYze{958!JQA+uf zxzX`|NkAAZ$qd)%le z@^>29Z;H|YfR7s@M8%1t_j%2PK(B4u{)Ug;da=Lal>g6+_C`9?byn^i@eJITF=%4j zZ$bUgGR=PqBuq&kns*Nr1{FT*7zUSrxcu3r+TeP@+0WS;c#apuJiIf1B~db?SmbYj zcgEkA@9CxA2Mwb$AIWbEL2tW9cq|}IVxs5`1o*0Rh4-J+?s-zb4IE89L7p_gNgnx- zy-ADGgCXsLd!MHZ$o;ZFz7Bk4b*b+|tC1tVtYm|_E88uK+yFc(bNCQsI!V7oZTb)6 zMzO$Vwp{fJM1LOfvNasi?#!C*$_B>|&JaEBr>+7eB@iH5QWh)dkILyh534iJ4=9`p z=gGNOO9HjOP{aVPxBvUg(wHbLAbZHQG6lXqccolWDx6nxMrz5RXyP*6_@&*(K_w6Y z?2#s}Kw;IR(mf6I5Aq{qRiL>z?`zQZixA7`M?bK?u3gkF!j<5hJvn>8v059ijR((n zda9lZ85@h9EqWFbXXNMR=Yo9BCl2WED;>C5a&X`PJ{E(-Ac&~#H`Q+{R2veW8lDPK zbN!e2F9FeAEEmhUE?)L86u+3%C5k8zt%xB8Z^p>4b1b~qqpsLV1~?Ng++)fBPiFQa z#R;OF2qxiIZMQ@qZ|$qao^r*l+zGhOT2L)~}im0TU`j z`#%S=rqM)BgZxiCHI229thfx%Auzt@aW;b%s@FC?0(+?Yk~;_FF4<2``aky0Gfs+P z?c)FHiJNmG=bW?TAd;hiieLal1yoQ011f?jDxe?=iXx(jqF?}#Y#>OEk~3`1X=W$( z^M06F^zQ5RnpxEIrGC5J(^FO5Q(aFw2dG3ip&)NkoAO|MLZ2-zs5?2ku%IWzjV@a4 zd>BNjG4!IeQ3C#dRG=c2K=#Qt`5G?Ozu58OMaVgj^LEY-NU4!Iq+mMa-EUvxT?IFs zZf9xo0`%M7c6^OVAWzFPya1$;^RsF#e=Uk<-M?~&oc6U3`$Gg#5BiV0OQ^a1c0a+8A*-&)A5#_B4>N~ZP_JI59Is()owU-WXc6FZHJqo`5DDjwM7^q}M zQ4wDx`tPtx`P~=Vp2d0VwWZ+v=vnA?jS{!&)j-Zc}EW;a1Qm$q`P#A7k$S#P@zAE;$ELW5X_JcBmAQ zFxSuy^f9vQXG#2A2xK;24C4X~Y6vK!u?a5&xorAZyz4JONpipG-qX?=Qs!nvI3gkNg5U5T ze8upe_M7DV{wiqx{ZCKtENKYkd)2-RQ7CT>n^R>4TH^M5~@wK<@FL9p!Z%Kd;e}}F0 z??QSC7)~g~BtguieK%zfH0v8XRf*IoS+}iySw*?*Ug$ zeXwYt*OCLW87j|dJ0NBiw0-TCf#pYn@tFCDb_ryv+`=wOKbc-hM?h0+j^P}{t&V!d z5(Q~JGsieHq3Eb1&RY%C4)qc3@HqnhN(YdC7F8=>2Ecc{k~cd#LfX^z8eSJ@Y zkarNM+i6Hc{=aVhe}j=&bYPM`n=asZ=lti!mp~eL`l-7B3zbXd#`u5XZPsFkfPBj- zl>(g}X*|;MG?*SSj8hMRtdpI8Xhb{!3kvie@+n84#nIaBO!q_iezBhzPJ`Sj-*W6{ zK5yp&UxE7G@V03rsIh8*VGZCUog=@ZAG*(wQLkussAMn=i52T$ptkyu4nXOT|F2cj5%7<9_5NcW03{6n5(a(m8+~oR zbtOJ_^?%I8DgQ_H+eL$#XDXDBm;occ=-;W$Ctz@yR|d|6%aXn=Zz&XXEL>DH5H74d zzuYdh3wojtj5IT*6^T~Zz7 zGb$4YR3(xy(C?Hu=?J#Vu5Ip9;JsT<)Z2mQUMb5{kW|L`wdZ}Xb@G;z&LE%b9=Qu* z>(+fW%nF@TMy6H{g1{Go2O2FP;riDs08D<_sA~l!O9L8MGYn@TZbS6zmKaFum^s3k z21O?wWxX~0j)1=~BS76iMFPR;@McOV99o|Fg=+`sb!jT!;M14Cmgf7{j(?TftgeH^ zDTM`|zHscu?5|ySgL+-9rX{~*rSZ*6X@$3M7N6~)S4pdgp^D9WvN7EUUh1jldAd^Gb>$oRlE#Wn@9cNLk7%y6b%*5$0raDHp zK;Dqge>Sz$&IQ>5>ag~PX)rKG^*4MD;*@j_|I*F?Ixf7x!`d0O222Ifqpji*U6%|droSJeVjLQIt5FsP@sIJyHKvP)$q;HRAu@;Qy7$ce0*TP*Z3^AT-UwXGVe+`l1Y1215|4$->LAl<3Xs_ zEYD#d1L{NBz<%HYA%0TJ(zVMjMl5l}fm|;gq#Y!Ff7y2VP00B?dt&y>kg_A|V8LO? zKU-w-o`oB>wA6rk3 z<1O|tLh&ovzr@At^0gCs_}YMn{KuUo&c7Nx^(}0J0w1!RFzkd;DSba`ZimWc zDtD-GC!}=9zR7kkqeu{?dRynIk~i)L1G*ULV(7-2#b? z3r2b>gI15})aLIO`7b&C?tTZzVec6UfJ3pFlU%Do?v=jm0u}f_bjXc_pn-Jtx_KQO zn=gsS3oO;A$Uc61>VFBy8|-I4gwD5oYWWoE9Eg4+`VDB*Ev|Q5Z>V@GtXWtyFy5fO zrM(66Eth^$zU_}jv`+;<&lR`0A#JN|mTeYzvUFY7K{Zng)B;c@HC0Uo+3t(%q`z%* z*c{*->TT<73+iE7)B0C@Z*8@S4DhxqoS_DT=h?ho+A5%dIw;q$&akW$FJ~dPN<^X7 z1||%>>1fadD8D~8!jKA{Z@kaQ#~}OUByRYh72w6@uK#!J-J$oE9S}Ip8lu8s?3#g_ zgSJD{yqacnHPF}S?br?&|3`M6n_Mn{TCCZP7T|hyLfZ&<$S3jF4H2XH{o7T#)nW=f^_91Y1tgZn#`6{apU1VA28} z47R~Y>wx?=A3{}6nd)Khf?lLQD$#)Xf3DzvB}!O0Ll^nl4kcX`SD(x6D&bl-ZGIC< zczjCy7>D`E{;nHP;$v6;0r5v>_3rYnM8FN^=98-|gYNx1Om1=j3W6O$`lpbxH}h!W zG01%^r+d!5kXZ3@r^{&|-K3MW2V#gN_G%C2C*ivnpHi84Fx;ju5+l^f&v~tI6GXq^ zIP2;P60Jt4uKbX^Q-KIV!5QW$>)i#8uI_kGJ`j$L0?2l{Yk1=!{ccxd&vcLk$&!U& zSRVL}@f@@ZxO0Bx3s7-xy*ontf%NsxmnMMm8aMn)qF6PcwG8H42&iFAG@OFCucH@R z;vnsY%)6Z#P;|%$sN$PS-@T}&qSr^D>4PA_IJ*E>j6sR|?zLI^*+`io00s`}&%^#M{( z>VfQ+d*mJ<%CC0tOHoceK>_GP9WSZ9;OUeTr5ymO@TQ-Q{@R3}Q$atX4`C;?>QiU9 zc|JVf_1;>cr=i*RwN{(jfST%)Z}S}Wz9OqYzfONo4ucq_gQS4|ynaDWfw!ACT{eKX zvGMNkc74<~T{f__GFotg;hRg((30aR@@ zRapSR`_5C0UDB=?))Ju9st<@t<2M;HXASYI&2LFA3$`^{@X z#>kUbmDT^xf9Ovw2xe?!r|klHo7nJpHoe_1uY zQePOcr_Vc0!@v?~3e(nuOp-TbE2X7?s(1(QFXfI{?Q6&TGXR1X`;R;SshI$OCllw_ zphSvD^_zU{J!gEa^0WW{qAkgv3%~BWUR!@#>O%QyF`tE;gb`2l=eizXeKBxl=zd7d zO@Aam911_T-&k}bTzKKav!H0NBivi%50(#9_%`ZxAc%Bc2Ys@%mQf(t%;Y2x{x@^H{I4m= z;a)03%640x_hqns>lvw61obKnIRN}OcJo>+BNp_}?2pO@@U+gmS5F68sI%%fu>SvI z*l^TF2ZRKKfU2+NtN9?UWw9&<87pgLEl7D@=4FVe zZhgr55LhM}R~lD>%;r13`xW1-5r_cmWIa_u|G+jzRRL0&OYl{ghd&C%8D{56!3&~G zYm%W&+xl;sFTkr0Ke!>x4UccS%^W-u+SaRoquB}NE5`LRFUZ4WQ)z_dc zHdPFq4wU0&zW5#E{#x9;1x91UTyr#&3rubaj;EuA9Wx7!2ti$;aA0wN)jbekp84C&6WnITV`L#z5t2i z@-y-?z%|j^)!P-+ZNHKuvfcUh%f5ANb-BD7` zZ>sl%Tn8z0GC~~@KauJ`))(=|f%9)=_?JYnY~TvLGIv7UEfu;3*rCHKBX?D44VG^s zcba^(}GU zKaLaNSMW{$tx!x7(Z<)_{l2fQQF0S<)gK6XM>fcDFs?A{ReNFBx$dtwtO<4J)=H{2 z2GR<0t@f^vy(2%S=wnDpPW~o&AY|oc?#dbnbX4D{96+e*mrE*L@OwlhK#it5M6Yyo zaE*f6%X4-VRs+KxAM3w7q6VvYe57AtpjVYbsS390u5|Yq(C^molU3jjkmYhcB)#Vp z&nw`(U%x>Pf&Qdyluw~@i`Fw@+;H9SK{d*L0ESpYqPht3fm~uczK!rd!2m7J2)NE) z8lYKM8GyJ?qh7XDfwVzc4?43U?xUz#mdX%-^%Da>kP8-<7W^!JZ16j|B(DHL)KhPR zx=)L>Oao&L^VX0BpzT#Nb1DK!qT-ZI6SVCq^+s_#tbSH4CbqiAat}2E!C}hq?pg7+>)fza|CR zw{bflRfz-d;KIGC0dTwAry>A2Or@(mIllw`ZJS&m6)$+bzSR7ZiW$?dc7PN z1w*QK?jP_lWG&2_qlZJ@iMfgO+N+pc%Cn=?MA}{XKSq zT<|#>ele+P5tn5fsD;`^<0(*|n->KY0L`e*uHQafvB_bwK`k^rsAWO$M~&hln?pgx zom0|Z2g%bf(gX;l)vqGUEyRTj@Ry#@l05Q&1+q(a0WJN{o#lTNQxqHEk-kh7^$~*@ z1T-Om1mFh0Oy6#jNaFwNbNf^LRUc|l1CqKIbSUTmClj+aWNiS?w|Zs0GN=J+qM8W# zYn>aN8=>Z*=*;L$&|E57MFXeE`du6s9)Et!gW54w4gw?UK4ZQGv^T9=)j5#M`U{)~ zbR5J28fO1|YbCXr{>4wAq~ZUhU(RoyU(WBMb%tNguh{UP>W}ze+o}G)Wu5>zER7fi z)eD+;ju-=(pWXCuh38?%xy3!tJqdb_yRJM3DV1F}dW>M5WpJwt5W2w-r+o`{<;w&x z1Zk)qU~X?XXSf|?3um|l3{%&uMo^)B!H%M5AZMH9Ez?0bwLGjSCtWR01Fmc3 zhC_AE6r^>Bw78rsdr#07XpPibd>KVo-{s*i<+e=lwGT}6wVQo!Zqjm!WdaiuQ&Q5> zN@bDsABum1sRLX|{V$Ph*UZniJ*-KI)35%GFOK{#k%n>_n%_`sV8R)=v2WKgEgFO4 z0dJyq43ZXRo+_vSd8hI%`P1QY?q&0(Wgt(;1pPjsD%GfVwFmPPC}u}}Shc1$Sm$}q z=)0g^QudC*IuI1^9_9HKq=g!++5n-LFanF%$sw@6>;B5~A-Es+p7o9f`IIj>2`S^9 zcX}+4pW}H_zYJo~V`VHvyje9MxE^#oIbvMpIS_at_(aV z0<^*AAyH*P_18KXp8|?FD>DF4d=Gpsn>Yp>ksC+>3nkkA2|y_|4w!o5&8F{VmP6$pC5RM%7&_C+2d4CFTFTWU9u z&SC2+tQqE-j48kr3 z*U{bp&XR-|ysP#0YzMhS+7-k9*C3CBEC!_;s#_+4Hp`S87zSjsgBO0+2z{&A8rd$- zL(t-S+al(JS;cP-ybX9)e?sm9eksqj-yvn_qROlCP_0qq(a57vqgLd;$bC@T9MdwU zB?K)qwKuf~xrZ-)HiMxop@aehWQDAN!e?ElU8f<}=&0nV1YWm3O`is;J5{O5|I5fx zjff{6JfG{g>$gK{*TTMqeZf;+kJV#A)lsjgS3sVV?Xn#*>e@HiH$l-k_tWmDf8a3q z9q`TCCP|UCVC)$AqVawR?%8mD$V8yGs&A?Q>N=HZs0XT?8n5O6I&QK78%O0Xppb(y z7;us(Zvr}Yf5|}UffTq|F^^E;5;V#$N}{P zEeVF^_w{O+V22vryDW{10KJLaBH7?Rr%#dckaWQDk>?F?w$-l_8|b03L+oI0?XtTK z;Qd%WmrSm31IRWKhyd+6iI$;IOUoHq*axB;Iu^SUK!Sbb)}^*2pct#vYV`$V7G&I# zQ4!MSq;5+c1(}cM)wI6?8K?647A=IvC+g3vITeQN=`yqKP|((Em6-stQ;zd1VF%cjtZVsH&{Iz)Gk-H1`QxG{nufw{VsPF{yi153V>0RDBYN0p}=BFHbHwo^iMH zgaeh)aY5Ercf21@Ta`jMBKCrnp&u|{%Rz}USL_*qttO?F+C_3PX@>T`)ou4ew&mxW&J7)j~=VcbC zQQ9l!WuVQnG>WYUTIGP}D!v5TZKg+~76H?=1XCRdZDgKcx)0)O1|7CG0ZErfSbDW5 z<1a)4Aq0ZFBwgeV&;z6~xu7;0o(VV(YPET1LO;+dS)Zyf0knFiPa}2%b@)KL9T1SG z@i|)lNV&Fa1qPofDJwa_3E(x=Q}qOEU8BWlfxtXdvMCv~IAv8=3~JgP~{EJTH65GvO}K#{lk;>`dQ|I=}2^`|lCC?JQTpOn4xb6ltfK9=s3 zPYO+iCfN6RN{f^hu&+)^K}rFf9-ZyTc7V6DESKeg-{8N}9h)x`L2XdO)G#n?(r(di z0lp)VM8M;ZiLU1?XF=Pl&a3mFy`}c3JwS@T)aSRuxBJ*GK|BK?bDM3C84K1(@_~E_MEbZrq_66!nnA#EPrA1v)H7wTFQ^OwgFG+jbAkI*JL=-w z=a$CzM|~R55cECz27NVLGGB_k_%Re@6$~j1g5=m z%A^=TUnC9niQNDKcSYKOZd+`Z=yRr22_)o&$-T~l8i6pX4M}6(UVI|JH z`Zqj>0vsT{AAdgB6Z3^Xwenpdtr)L7PhVdN-~ zWa-LS{&bf6YZfIP0ZpwrhI0_NI_ecm6r}ac9OKM{qN9#DZ#7U~so5L`m7pF}%R#GV zdL?2cXl1SURcHX}F;iMh15mfC$4oszoLpuB$Syg^>tK4<@U4~(HTp;G45by@5XgL9! zBmziK5B*L<>0kUbeCt3c_0_GQy=*NP{w}B~+Vh5*ATDw^`v-iBn{*sNS5;n(gRrD_ zqvAS(`Lp;*0hfSf`m-{DU(N~OPsNvqedL*o-GUoG*3XF~+mqvmHE6-KZNO^}RwV6tF9IlsgL4T)NTiM;AIlCYfMZr*2X=LAlPM zS)o}Fc+qsubPjk|4$EOM&CptFt)W~}=$6ne5U|SF&Dag(3BSYa*TXlijdEG$gRydi z(L4sicXkR%hy_){xY{%t)Ht=$JRj6+h9TD5K_wbr4%r4;4|BDs`#`NQe;9uTv>G`Ejrgj`_^e3%F5UkY^x!qdVRk0-5)_Hh7N%fj&oq!{~X&(+ixD-tykvKvkj% z=ZZxkni`{eL2Ob{n(GayzA|r^%>$~tJi-#-9HD+W+S0Y_DGnfh#HVUC*xo9DB{Ss5+dR%YAmxj!jRor=AvIx0LNwgbtarI)n;__vHQ96zNC%l9A5mHg9ZHnG z*Yf8`kIMA_qqvCD`*$Y?{M$MJO58Xb+QbuO`{MVo`-DrDf#m(pT+dc;?$9;a5Big`LOz7bm0EulT@G42(q~ASHK3kW(|82r zJNeR|l2kgDqSA_zr2!4C8HRHZw?6t+ixJXVX0~_U4UR!Bt1$?)h1R^XeL(HCv@7EQ zHP6u9+5qrUz!4A^seA+!r);|MqJz3YEnz$~92(amydwmTH7z!@0eOrqze?BpTE%?! za2m`Q^0Y7rIA$DdumV%~N{-;;P_Tj6I$Iz&g~h#IOWpF$XyaB0SC0VBBRGW*7#>uha>30x0GJxN;$XGtuXWhz<(85O@I^ zwU6HszXR&dj-41g5gK{om&GrGite!M!>$K)LEW$J2Qsi>`wioDlSUDsdPauctS7+vu0|PM})(0$8LH zfEm=I?3Xi8t$W^3+b0m;+Megg04b|(rwgTbS8DdlZP)jagQi|gsh)BcvU_Ep&)NxT zO>$P+tdL)|$n2R1U7l_8azhT*xum{~gPNyv&)MFE zs9nyc?r9(a>TcDYD{QL8DWi_^o>#oLfU}#YnfENn3^H&+`YD&iI~MY1dn)Q5f!wHf zl}8|KS;e(MLD2q&+YVG51_6aZlMI_dI*4K=p#4f#=YKkkzSJ#gCS92W0gbIDLvM)R z9RGYwJY*OP9*w*i949?Bf|i52tm4(zAO&)YX#mL2X=z9+sU#zz=EA6q(DqPaQfPM2 z!=QJP>T)-w_l5WeL2lzSc0u^F);CQzLcnp;V1pH83Sa$Lhg?;q9Fd@R(chIg*mv&a z8>!o2)4cDyCiR5e(JDbN0+oeO{a17#hs*dWkSXJGg;;2GT@9k^oH{%JT*F1etED1$OU zm7<7E5u2b~>f{{EmcQ%aNh^=jAy)OuB$IuyWOq*$^?S`{1&7 zfqKvIo&uy$4*Wt=LBWgfEs_i3BAw4bY;sgagA~arc?3w{E_Dy6=L}^nvq0-+E)&%g zG_y6XJfPJGc)j8Q(C#yT8S^-(DO#Sz?!S+5fP)J%2cJ9X>W71VK*?197rhsyEu>6O zH#tHfFxC2^A?`=yeq(&B{{P?_|KA0<$Vm!-n(QPMnoR65Jl+IVZ|m4Ub_wXC1=$U* z%X)WlLGo&6nr92Rd&q9-1Ktq5z5X27zH)VNcLaT_^p$Zy8DE57X3|(y1@kN3u6i`o zeKWgX;R_Hn!M(zp5A;_(Xvz-(v(ko}xJBIx?!B(}+^@o=Ef?2c>;kqy_HP}}Ly{}w zhJx3@>J3T`-37Nl*{4B^EfAj-u_v4WR-#@F6;z<;=$|A6Q3 znhEf?a{%~nRPm$bUjjp)_O6KjNJd;5h zi$#`zL4vGC9a;|_zN}&+h|8~7KCnIL3-lmv<%%Bczxc)QsUf&XlNF$9skxd9)Dlxp z^kE1J4x3UT0^%mcO^oOaX|9YWwgpi1x#M-uy`c7~b&SGSYVk7;DM^w^EP<$Tfiui2 zpiM;i!szRP1cI>wMR@+s8yTrD3;7Z%Z43_zY6C$#O+AcjfZOCVcK+zZN$OTwf}@Ws z*n0dYl#>AE19pZn{hLec{)R$6OJ_2p1ez%MU?2M){ zxNouCp-qE=>%wPR?tz>adz&&CG@Btk(<_-f0e;OSGWgYX>5hQn zQkGz4PB*7R-H7Oo(Ho(`$+(4a3n8{_P-0Lb(2fdJ0PKF5&XOqJ5f$OV12TXWtN?u* zqZkDe$82VE#qsc~H|WYwqWh&BmzTld4eoDR0WnJlhg50~<`?6R2fPomLVugb`Qv56 z1Q!_~4!OuYzk^^DP?m9O8mNyAp9CxhwZ!~HTu0Cv1gx*r5w!O#bK{-^HCO9mEdv;^ zQUPCvz#IN6Uyb)qNpim#-m}sgQl8HUbc8`*iuDCU97Nt2zTdnSWQ;uNXZ3gdo!^&# zI{eS2JR~=;6)fLcr)t}v-OgJJE8GDQiB+41v;e8CH?#F!7WIY9HhD9P-h+mrb=@^O!+=vAKB%=7 z)F%uZw9LyBSiZXFgZ(3>4mF-|n0bi4!i}cPR%P^Bp%9wE?E{ zoGKj`^`->`dE67cyP(eUoHd0J9b!_X_lDI2L=J1GQJJ!&ig(la2t%!GR03@oJ5F5;_|y4~tt4(aQqgv1|eTpp2D; z{QWWk3UT29V=HaGDhqWE#Y_zw3Wn2Kq8bQtjLiS2<^P0lI0fe3#(3>Xh_r^LS*L*B zSnZNCkUt_kPU{4+U#q7o0HOZG-Dpy<1I?9@yP&X1Sh)ERoF89nLs)g#eRGE{@ta{o z-Cj?ZTMM7x*=J$dQ24~vZAg4I_#~~%qS(&x$=Dmp#*c!}pX@WFY%Xk0?XkLSV>lk# zcw5wDuwM?zH34e7l#`EuvYev;kUw~%Urdhn04-?=YAbhe2dH8L=+9mQ4@w>4z|bq~ zqJA$J+J-Hb@xT#jM(m&b-Tx#wNaHN1m(<7FO3?OOuM2hq+04}!fwHK|>Pb)*$}<`t z31-M2`2EGT{z|_{Q_LkWgKcaB zj;edqJ)quG`_+DsN7=#_Am1P1|Et$Y<(Gp!E`#JNP|?N*wND@_vG4ivPeSlLO{+u= z2i}!uWIW(wcloRO=1cHT0V$HxOaZ(UaURrYwZOCnw7X36qdlNi4|t{G2GHKLOo)pH zHCa1t`2cW{Dj(q^f&A`A*Zs3lQqFIx_k>&rDRVMH9T7i~>Oa;O@yCJlU&H?ogwf9p zuugBwScrMQ?4H1C(00LXNfloKM8j9X? zedYNOJkNNi=$StRxXAabS_S)Plq***Xm9Ti@rUi7JGX$8Rd>+kYEQz?pn~sxD>q9o zy&EKccxmh95m0zr!A{#0NZy-SR9FS{>Z*!qA`F?_eMWO9)Rukjyn|I+LJY4AVz zx=9`q2Xy$Z@y3elpkuFAdG#wo{@$W_9v~wn*JHm3SyM7|GB-l{jp-kyjRmIhEHn9~ z;zWNXe6RQKi6jKHebPxDg&L0Bwzd?AT;cr4eH0`_-SrJM2*>bDF*wc7ewFX%w3piIQ z=cn{S0S+$8Tu?)_p{A3dwpqf;^a9n`xGf?Y2&bd+)tKh<6-W!|$vY6x$9lVQGQ`~ zN%A&CEDcy@4uOUtapB?Bfm>u1-|_!mNwQ9MaSn`k8b@g1&~kL$V`XBY`SrC|B&0#P zK8>?t(?I10o-}L*(q*u01*P;OG6zz$3bvr(u(o#3x@D)q>StPnhL?d2je;7xXTmqN z&Q3|T!LBzqRXAQ3cAfeleqStno3pslcTd6Bw=9j?slzsX{iEMcgl|Ttzmj<$th=Yq z!$Bdi@viPSlK4ti~(i3aCc&*PrQp`gF( zE7w=xxk0a^*8%k~t!TxsuDSl7Q2uviB2N(t=HxQ(duxJLEAVTvgPfClN@WJtwTd*h z$VZ@UG`TIWfO>E%dx81y&P zRy7VhE#v?LAbEnboaY?4UXuQzfu1Q}NGjM*xcj<$gZ_wAlb%3%!UzF*m3mYHbE0>S z-VN$Z$lgXPE6WRNPTMxm+|1J$b{+joO0wM&mBc1+rYW$jPfcm>-SmKQO@m%Wk>1#Cd<4 zOn|?Q1Hg|GH?VJxuWh}l#CfKx)`rMsfqh<=exYK;^Fs z?zWG^cZU={52yiDTdGhNJiWccyoaI4>UMaJ1C_}o19C$>UwR*atQXzeyr+T5aztJS z^T>$G<|t@;WcbmFwIHl!G?qD_7w8Lk9x(n%8?nD1)Rl<;tDuHy_nFFow!;!zW+W)H zF*bA=pyMJPpZ@ZhE1&dn1ZW`5q&tftpucs5@eznCh*=(FgtX9%p*GL|&IphXW20+GW4F!upDDG$gZuKxD%_aeae-0NO3&<~mwCQObz0+nOKTLldT zy)rQ}>?b}~90?pI(^w5*-GdKVnnH^~wNIC60Zk9Itx|C<1n#XoEMyh%tlo;=AQ!Yx z)hf8Oywdj}4dK*M$9?vf;BcEIv-f-rCvJZ=bVnv!dhY%12R?wbMeEO;`VO*g+Eev% z3&`qyXj9VtkkN0?wo7?%xyjm=$1B0Pg160kpMj$_7T>))4)!h0Y@KrhY@X2W=9v0$ z`FPceAvb{Ey%sdy$IBEbfF7>oa3mF{g^=I89T{~VEL@-W=~I0FKGA6X247Czw6B( z039bqKph@a%fJvDkP#dJ>LqQuY6{ZctJ$W3-pAQ8^%Kzd7B#u>Fi17$OG!6@p6*_j zI~rt;v~ev5(s)w=F8w|Qu1tQ9Jd#3Cfh&ec9XQe5iePd~@Z3fvd&G?)jG6hN>1pNn++TvC{uCgtu zpjKPmio@H$3ec*&2lf;x_T?<;Dx<^-6&2%aN2mK*Q*Hl&zfC5f@dEt(4H8R->L*Fx_6oYx0apA(er0gb@t-gHl<# zgI#xx@(c&Pft(N%IJ5Msk^(7}oV`3Q@P`tf>+i+a?#~`oj z8Pbm{Y_9*}f1=p%Pm;Gm^;K<5cZ0UUl9sR)C@|~`c^mMM&jEZSOj%bx`TtSU5ir0y z()cLE6~=rJWP-Gyj3G8R6n*Yk;&~p_Znc&>0k_`~;MZl>4@$Olga%_{yM(_6U8`44 zir)ZY=2=#7?Q#MbeTIbog$$RMAhKydrnv*$7+HILxoKd1)ws^^2FQHb!|9*BjsXp% zv)sq~Kovbz9tLf6U~S_u2+nCdBx)t7{o4J!04}3-fguml_QV)1%^Dx1NAiwjm z`_pQJC%2%Nvk}N5d6f>J=4;u?2!^)|aauf>o-s`~&HzJMF>af_AUEH-wjzW#bsD`gEmK+kqErR9(MCXD*vOj zp$*{uY4TF_pf95D9PjDs=?Z7x$)1}%7xK$EYdUL!>$2DD^+NhWo84xIiw$!R<{kt& zC}U&{5KG{H7<9iLzNh^w{WKN9cwJPCZU@WWifg>l0n|oA8?HX{h0gaoPi)w&c2CbLEl~!b-@I>(~)x7 z1NtQA$@F{>vnM`ZfsFC4a4Z3~h|@a|ILT=JIN&6irJyX7W0b$d;9gJxsu~XhhouYU zLHop#YXG9(8eCNAd5CFu(~Ff2U`PwrP3?f0dYCNW#}(w)>hn?DZ{PdN(<-h>PKsdkfT+sc-0+97`hPn7MFs}Z_{@1{lA>iZ^^ML?r zFcZ{eXFwcxW0IHt)OnVe?a9(DYn6aNjNpipG-qX?=Qs!nvI3gkN zg5U5Te8upe_AjgdRfG`}3PkB2GZ#W1j51oVObu33~(4Ohi36ZWJBC zkY>#2Z!3bLFCEJ~FM`^o)^G<`909UizULB{4r#-+<#5xuy2Hyahw|sc-V5vqdL1bv zw{yjyF7+_@BZz)kLoHGn)mpe|Ufrw;!O%1#!4~ld=sWaOY4_{LB{m9i0ZFXkA_R|V zS}*EOFkOy*)4CrDKM%Rt6bD)Mz=~Q5*p6T5opTm=Lsrrg=<OM}bgk5(AQt3m2$! z>OOTJSkD?R7%o82G*f+3eK0pLgcyQ>>(zs*E3jE>tQvspV%F_;FC>=v)bsr=IO8p7 zQ+NoDeAeXIsJ4)H+2eGqgk#3kb!n&I)ZUC{nNeU@u9@x~pdO+Pt@;0(n<3PtF1YG@ zD|;)0bB_0W@AsgDCwUSWtD39kz)HiMyE*n9E-$RVlC-yjlj)ggFr0nxNly}-~ipl8U_pp`eYG!6pEk%N5wqw^IS zR=`ZW8Uh5-K)nl6AbaTs@|OOP>miU3PxJhHK%e9~o}LT3%aL|j1AT8%{R<;O-&|C9 z{#DQ~6g_=uE=XDDxWtp7w|1ta%mclbt8VHupx^8qnbr&RVXphr?f^a7**#?tuu?9k zIU&N@?E%ALh`Z&EheC&e`K_{pj7x!+^t!ScI4yT^9v^AowXkj#r}$rx$Jq}&s(&x_ z!Mr4{QNT`!FE{eG8t*{NorAPW2SJOpzF=qv@}+)+Is82`AQZmeeYUR@L>>UuPhDpm z1?qM4U9lOUj#zq>sQ~H`?V@EpP{bK|3ixmGf+gkrW_r&{8%UXz5$p)}r~1eEQ~iC0 z|I>cM-~O-RUkczSla`nDROtg%o@w|-_-JTY)c4M^vq6G1n>r5OBFSegr1W&&u~iW z|8kZj@<83AQWyyRZ*M=fwgaj!sM@;HTad9iH=(FEYMcP_N6^as)`niup$@|NFhm^e`wg zx{5rjb9CHhB#!Bct|P-h(#VZ+)i1Ef5?QzTR97q>d!= zF8|8={Zi-@aRF3}8mMZ3dceFP`dLsB#?E2a1A>D@u55gMGfFxFdRd1XCqW!BYl4Cx z&6UyJRscnt94kC?e&h%c-v&w7#VGxuYCuH2U^CqMXuY8ogTNGNn4)b4d6m6aN)bvU zEdEG+N0!PKP*2c~y3p&b>aUb}1BP~}_jSc3V3?{}t1}>9bCLAl@qNqXWtj-(re)>? zu7c2wE$hZ4LvESKp_W9*-{n5yF+q_jsZRb&Kph^T(@$KdxP-?~DyHVE9;yduE7W0i z80bJHDgh23n>d0O9e7*&UU|T=J0-H<4M^?y?aSvb!SP$;?dE9sx_z5=(NDthPwKxL zZiW+0A`8{6aJG?SL%|M^{<>GzgSu6=kPUeKDZ_pibnCsw8pawBT+!?_JAcGp?vbbD zDNwJ|o8A!7#`=Wy2{2@6DRa$`R|6T2jUvS1h#X43D1z%C7La|eTJuVT4` zPpACfb?5g%0cm_CAA&a1G|p@TL#u$^!7~7p3L_fdbLRO)*D?}{&oM9v2&REr23V<} z#)0I@R}v4hLDIctKql$O934PfdQTOu1^u*pZ0>x}SGhN4l?VN8*Atl?L4U>7BjY*H z=eoLPOagteYjS2;(4TgBvsQyt^32S62|}hf+h9n7vH|1fg+2{o!R_k?bOp_2t*yQR z#(3vRUEq>T=MX=T4PI>&_aj9XauOKt{X{B)_JU=ob`OO1YvYN%3CdX?excqs5PrOK zulNn1a*b!yB#@mF$8xU4i2tvdBcBZ6CqN*z)Jvd6n63}&2Ab1)x!m=jwi{xC0`NJ| zck)B#oIk(mis3(7zbtJbWk!a@5&9G4e&hV9{{Ke&OC{u(>?Q})BsGDDpn0#}0~1C= zLVm+m;n#tz(ycNU?1#ObWhkT#a$fcf1}Vo8GQm~Jv(noUoOgLPc^?Bpef#6$0GT+{ z{i+Ydt}Mc}0xEr(KgRw5PzDU*j}V(w+RJP&MA)Xi}b zl80pWDQE`)p}}v4#=+34-Ct;GfruMJzO~*0k||B)SxO6cSBXCKdd%0hD9KuI&1M2z zvkm}1N=$r@LB6)t<`U;!y~uwt*Cb3=YSAG{IVdW1-^ynBdU@BCX1dfGoe;Y?y$mc5YWie z(Ayv6F4a-h2Vw{!0Q58&DNjPt?e5pzFMz&VmdP1#S!II6Lh8rP@!oLoCQCN=fRxb+ z)KO@-q|Ym5u7`@#>V6V-Kge_XCF#Sz@_xS@zKDdsmS5E{E)1Uxs+*}?WPiX&Bpv<7 z)BK=kNRgZ(57cW~Gj$ZgJY6~^Q~=w1bsh?P4hp8`9=1;h z_Y=8Ii=03|mBJH0J0AaaeX?SbLIDMU2QOa!|FdBv5HrwDtza1BmOD5i<#xExcK_VV zJ>cljnA(;maO$S^!z;Fc3pd?5t-(e3{_8;(Yn+GkLu=d_dKY+gqe;yNHD7wj29Om# z`A>6y!(zi?sJSr87-fXARYER?T!e`F0h0qJL*+*!o{V@BDr^b+AnXHBy{S%hd}<57 zMeNl>78(#p9o!H!u~7$i0hpS{PuHISS*LHL>W^pYU;HL`DWU*WeWt5V!MGyuwa^Zr zH8oB$EeFY#J*@jfzR6eeRICE@y(HlYg z&N@W<4!GAlUt)j{^+ob1VB;`3Tycc{3GiLDh*RVPpX*!XS>O)u17ZPfyg5^A4?*o3 z4vcsa%EXMFR(ma!IWp#<+Wo+KW0n3P0+qgwZgsEdjazIdm8Fr z0)d?66xc7iFS&Psw~wBw_W;#`iX;H%2_XQ~ZSsJ;4%JuY?XY))@S)BY?(2X!btl*J zgW6VUL2-a`tJp<112Hfc7o-Qe%6T6FTadTB-UVcaZjkm6f2L8_h`G>oTrVx5F{s|E z9e09^m4hty_vPO$_|HQFia0CNKy5T+1x*3)%s5QD2^Iy);D=g{1555#-W zCm0A+;RV$k&Bf5h1Ci-hb-SH1Ld&ZES>;>8{zHcnDl&xW&{KOt&GZEjp@ynnAbnI%)eM3h?$9Na86PrU+)u>I;Qy`^5)>g}>P$WrzW9xPGht9@v+-yduiGH=JJ(LnHsDq{Ar3HIA68&0gjO%y z99#Yd2uY9ZW9|uh1@G%}9?(iHt8nRouhu_<)u4K*`o>Q|^O&<^Yk)eSwKul|aY|pg z-+%sJ5y2_x2+*vW@nMMjBIezo7a+}=G05hGxKCmh2R-L^6g&$0KItnKsIfchQfMo< zcV*N5)!M-f@3z&)c0=A;$3C|mG^6tJ8K^JREvh|GiEx5|T0{{7s=7~}k|+YPz?F*o z6bf*FoFij4dsc3fC%F}!+lWYxrp&WPebR+mF|jr z1G-nQIw+wAl&c?lFyJGgsd`AYgG-lE)AJ|7-bp7Wru2i_cUO8Osu$Gyv|>cmjQ}!= zcYeqG4)JYBTrGG-&OzZTRd{1fhPaY;a&8cIXZzj1%8 z-wWC$*9_?jUS~m~YZ>HkOZ&uL2^{x-UzDB<1%q2ZS4p7gn;V|5c^61?^=3?UXjWm{ zP3h&qc(Z$uZU9-K?nMVxPKBrtFutfFRU}9=5=a2~nByGh*Bk!DPyac&i*V59TdGJq z2ubPip{o}d`$xu!31pj|O?7^|tl_`#p@7q}AJi9GkYNfK+XvSTp91O~LpMV>NP&FB zKA^NDgZ>nJhQ9+Ji**IYg4WoyJt79wD$BY!GpM?pHp~NYcrVIg(B@m`8CpYdzowg_ zT0&4-!&4ELz&#?PgX2DMOh5Z-K?AU7om!ZG6r2xUJX6>lJX>=1y6yn)hJtzSBcPid z$Gk0olibd?aD@^$mRqO{YQ3e5W(Px;kX5EKV9XA`V15FuohqaU4}yT4>Mw>41#9GyB?RW-k(;{#Qfa8P?` zPBc)~&o$uoXG~1vJcS_5WiOe)hos>E$@fPT|IBAe1F^|jUIaB#-Dh|c^y^JG#$JTf zrKxw?n?qn`zz6Qh5P4(xc2gH%tjr{ze+~a@9CA>$k_k#_x9}b`o7u-(=6$%d?cf8s z-613K`{8+2z}C!jRNn;|Yh3Bx_n^%4mi@*kaMkqI@EihXvbTfg0c(P>yfF@B3#YjR z3{u@y6DZfV@MT9CNa_(Z)w&xl*9dl4?*paDY(4>WN{0)e*kE7FCbby~h8NtPeH_CH&n)mfD=TRY`WxJ%98jlQxAF0tp{ld-xo|VcPCZF_1GiwjlA``E z{yPLO1^70m<3M#Wg+!GDo-`PPZU<3vS{~y+^^E^Y6gvW1_)7!)5&yVPV-^R^gtU;1 zn{950TNU$W&~p&*wa*bCvv@?x!}YIM{ywe&q>U?F=y(ObXnba3@;J!JbG+-S3brEG zi{2>k)|6Ee4c^&$NBt0Z+si|e0s1Y{nEQbsxzq61Evr$T)B;9AzTQ0Lv~d&7D_qvP@O!h1u#!!eV>)_gG-N*jbC8Bm6gh)4%YQ7!?6l;#5U2 zz8%;nbOLCbEuRM52QpLEau?viUaDu>0fu^SMtF7cp3wHE4YF!zox3~UMJ*Af~AJ_w<$T7MbaAM^^2w%#!CZYw(A zHG%imywh<7M<1gQt|iT5o@2F9ULES~&V-Uol;uWCdvMo>M}%~S@xQ08(8 zZ2i2I#R>)DSt{Rv=X2`vIcSr)lWGufP8+WFLvSy{_o^zGw`=$C2xtq4MuF^*m0SdQ zmo$q0z_AsR`wdrvXaL^H-Y?}oNa>N5UF3$K!(sgrZi0xk!1DPyAkAINvnztwNc5Mu zSpFpwy@pX-5}@nLc?rTQMUS@}gqDxpRJZ&&Sl8-86I*NWHn&+kV<5AM`z~)C2rF-# ztgV8eXACcEZ$QyP_dOm9m_9NT7&1YtsXD4ikWYM$P-Bo@MgJ6P?$145m;#wwtWTLb zfn%4kwc#W%OLlM^C@t@&XrhS*F^h-?lG`SaO^Sio$k^}WCP2#R>;V=aA}ZuybXOSE zp{u2F4s0yiz3uEhko-W_y|$j9y`!~KoAB*Yu3jcU@i+VDc0iD?eZ7vaJyL9^8WIyz zQqs~&zf13$aRB&X_P743&UXIlz)qi*IPa<%{uum`|Bcd3a-dpiLAPhyzS5u} z*q6IrkRg!XF{hF34#-Q)yEkt#WCW)_pB@4{j+v?W;vU0(UswK6_-lW2A>MR+8>>NwNR2Q5G%$I|p| zp>G8ZFed}iyu(>wE%*Gc`MjM30>IHi4`B${_B#%FbntF;HTCob)0>g+Spj#i?7q$( zAV$w8vIU4%1E>i6agG2VejpWe-~b?rq#qww>1q;)Rp!cDkXhlo7cXvs%WqY!5cLUs zKflgfaZf;*TQArPw?p7lh2idvAor^Es@osXvm%aS1dh>_Xb8Me_d|CZ2zjIZIM)N9 zdKw0k1d=7U`Aa4KU44EVe3ATQ*2-I87->li>;^_X`0MbQplYbslmR4HI+FLJ^Gh29 zFGctmRg(N9a6Le6vJ}KwKsBe(Pz2&4nPvWQ{8YqT`PD%R{E=z|ndtupfDuHo0kksK zF@{>84YVFGdA&*^FO+7CMJS`*JT3ZfNccHyMS5lLVygJ$1#xG zy~$z%Zbxws@HP*Sa;0y7JzT#1h5As{AsqB=@+s+%)Y5U6w;deVncu@*1J0Q9Ryk)w z=G%ofS9|b$=4q>c18S8PscJz;P(Y$-55$KD1)AzWl?}n4nOsoa5Omzw2jZt%q6{~J zd8z8o7?5vdIp;tYkxUW4o{Oc}@V`|Jq#k%5^=^<|kkUErXyI}Q)B|+mZiw6vF(R-X zNE2CLT?hn8Z|^V=+^^+*>VK|m_{bQ8uEPBPi$4a%j)3>{LKy%xK5aHVas-^++$kY$ z3mp4?O}nH`;EL5JNCc#YyWaNHgUSyFY&Smup4+_d=_9})?yo&9ATZkejp=K^>dR=8 z5OtU822sZy4crx=(#-|$77c|Hc@eq6h5SGc7*tB+l8Z9|-sdCrG1$%(CfkxBby4cZ zls*u+J}4~kL&)rzA7IacnlDwGTe&6lsMoqj^=a_dv#UQmco&dKK5ihA5Uf{iG$q!C zGFyG^uxEYk=s4PlT&5N%W z8+<9x#%VH3T+rg3v;nymC?8XpRrD0dMKxIs0ul%&5M-wekO!b(vg01tMsN-Ce&lTl zj`#KNWh0zvVIS&h0gm$eXn6_Lm*%$Gop62TgimTzgGM)WIT-gK=~j zDxiwkq87%x~Px$G`#xcp$X|1VBe6%pYQq%>~i^H zPIb`d*s6J&fO}+?*SQa*ueY+K0nzG4Dgl4ABjA5Q`5ZyqpkI*F5b}QQFJkY326v4Z z(V_-zL6E6Y8d*NCW6@;*(a_i7~;%<)+!)L@)@uC&o9lpl435EqsAM9GeFCpLy3C@m ziBNZ1%$~qJXx2003v(J&PO-jiYz3wmRgU2x)47NZ{%3(Q7zpKH=RWdmyDl z+Tp@?A&>wu?t{qL5vv1IfwA%^YXJ{Y+zGNq4tchLUe0-c(m9awo=F8a0s&N2{#|XU z{vG^_pNH4CU)65Z4zLi?>sfJ0a;@W?Eqv&{k=km9ONf6lDUOz2s}Vz2yJ<<>KT1On_3mb13z%D8J!f zB2%HsSzmiYOo`L4o^Qyn_pNW0K2iYn!YcQRejKj9xwWBQ0oeDsa^(%k{50=Xdnd?k zp1V0`9%K|{49lntyrCAegsc5v|5r#ObrbC%VXW;z$6QD#vM+V62CAxIsv}_VzsM^P zK`1ywJ!QN*!L`tv=ba3a$_^4CU3W!z#)G4yo+_I`zf&J3v!LSIR#T$7L+xIz4@XZ2 zDKFFHDZq`pG|oqPt}#5rSD z23a7@n9<)>1VtMh?|Wte^VI9~0WrvQJ_PS^$&=3Dt*kE)BY3^~vr+_}1NwML1Q!x}p);8Fgr16A28KXWk~Ie;S-#+nADv(N;4|bMoR=3tJ+D=PsE)PW65x`yi!V+QGu55J&(e4FAVi_k*0DIJwLlp!#afjW>d} z%sfAS9;mrmS8FA%JZHc)usi=3{}l$G3rRNUowyHTo-AJ};5BIS{eXdG<3KeruF-ab zE>fMBAZ?f{$uk68@5>-DfgUWo#0f>|?o{_~kV-O576K7iv4Heay;O4u`oLY=vjD0c z&Z}&H4zzfwBBOwlgcA&urnim&3wTp4278`;nQbPd8dEByyblFiY~MJ$LS}wmPSHB3 z{%zI#iYKARz1KObHv$sKV+WA!<7&FfDDkGM>L&vnSW*DB^vwN#!L_o)`0Fl}FG-bK z{q$AQQCGWT#gLWqt(*bVqsAmH5C%TbscgM+5VI?$ehiQnn?1qyG1wj|YU{imlC~wC zNqPW0QSNN_1)vvwRNt#TivJuE0FS9w)P#W6o>%pSP-AJ{9X0`Dpnju%2xK#5i3VyD zPZW3u=uhe2Kv9BQ^IQP(*vnoh*zI{pzW~{~yQVh|SR#kzO$eA6eZ8e3w4666rrbfW zvhOm>;yDcnj@KV5GP_5K?Lj}-Uo6;lS098%R*4+45s?S~RPW}p%bOiLW z4mVDMIAYcW1wooCqr0sDiZ(e`c;wF+FB7=>1GP z60$*WZ?ct11pN`?fVg=e8HV8Sbl_u^Y1)s^ArK0xF3){9J{%130Xe}IkRp;egD>^Dv~ni1fon_N(W2Hs9W_KX2DL^@ z*UEx=OZ!+Af%-^0tU^F7(%w?pz);;S--D}s4)!{b-EF_^as*sh@X@>jL*Q85P4-i3 zVUJ3Uw;h74VeWx?A5ei@Pr^@(ucYDstarN{fRq+#y9(ciKrKKs?uW=Ze#3u^JnA?6 z?N_v@d{AgVk`J6?xX$VTZLwu?d|gmoRFH8qz7oB4S3dDCu2G1M0zAOy(u{RbKcJH> z=2a-uqVeMqi$T`v@iHFl-Mx3o{gBblb&vNw;8PqZaLxAK<`r<2@qVUX52`s8NZc^!orNu5NvD3W8FGC-9<&9R_0{^GE)7%V2Rrg9j=m#>|52Uu@mG{v5D}x%x>UWaj1V zu-^%JcjZRqZilRmnY}V2fp^sVd;kdD>3+2b^CLL@5y@>N5D6913STYi1W{p*>h4EC z!qrH%8*uydN;yOl>EO8JdC=Pqyszl@>m$H>RI2bar1f!K^t=F`e7Vd}&>vH$Rb{BV zyT^cp3@CTH#+r~gkSDzzq%UwgCn>nvlW+~e$z@px95oCHwgVZ4j{+-##K~E?hbuL! z*Bpu+0nPnnfx1;UJ_K=_V^##sfi!zYS6d#$t&dqAG|NvWIPnK^!Q#*VV^AD%8$%^R zfJ@XN7C24}!TeApxFLxRf)IN6c9U?eYNkUWGhz^f}1QLh}ygYYLKZ} z)Ca(1L;VmP#3&Im9be{3-k;hJA1PiqVOT(2r^Tx0Kz**Jvl*09NoqW(2;XtBN;P>E z^x^UXJwZOy_sbZNBvL8#&-NcV-^HYT9SFw+e56_u2YFpQo#Z1p{*CRh`x7|*QNdKV z0a72b)p6UwImPpl-WvFnySNT=%R3r*Zi5Tq+n1jYgPf-ioJzC;WxZwfsh}FGnW`UP z#QU=hPkwF%La0Uzs5=yD0f4$4z;m5#xoZp90xk~A-VOFwiyn3l0Y^>!GwOpfQkGf3 z&Hn3^O!c4c-75ParD@uCg>OTkCBR}l2$8cQJ_|?z?vY3M5~PTtU*g!3A~_>Z0J^~* zd>+&S^YG|5K|-8c(l!D`oMbY-Or+>P@j3e!e-8Y=HW?^o_yPjGA@xm9L5p^SGRoD2 zHIq-=oL>$+_ZI}Z--oPS?ycS?5dN5PfVL2VjD{Dr*P!S#_kQ;gFx4}-w8ueJP~j>I zWIpw&1m;HG^11`69n1U7-VUi*Pej^k9B;l z?mCFw5qml2PPnit?L?ss>}MPwxt2llv&r?77J{d-yO&#lbk#%k;E&!$|8^A1{Ppn3 z`~~lIm-EbmDsSh%WA6qkNWPUfK$6sE)d^I4Dp3a9>%6b)MsQScr+E4U?McJ{IeR?! zdOJY=Q{J=sVUUmYPvl{Ue5LxykR8xuOOMp}mY^NeW^g^|S$Ztb0Y3<|{fnQ2P7xPD z)mF<5H-Tm{tq;!tm9AE32S98xNb38~y_V;*qS3N2Qo!gfFm=&Y1{*7d548v;}6Pj^>= zkh9kvaJ2?g`g4ZXi(yw4$^J_TGv`b?M~=@66-6dV4DoCZ}( zJ;Wj~TnuU+76!)mLXJgr12u?3WdyNv(l47_It~9~6sP=OFis0GgX(VH5g7njI7KMn zA%}0S%)lQHCoa68jn}%XB|v*pD1`J!GrzYlhjZsIZOf|-7r#wxS5OV~7xX4l5h|1` zdpzVTsM5V+ld$0sFEPCXYk;;*HB_&F-bNoMZTP`Z{;hrYGlZyN#9;;fCDxJw$Cnf? z@tlB78L4*LW;n6_XY15ca---aNi{(5W;;(_xC(kSM^epKQl^<`=A*?b~zq?~d>^3;ses#~J2H^Toe?r0_ zeUZ!Vy#p#P44AK#0k_NhqFx1@lRb}kmw`3f6lAOmB$7)35Uob2t`PsZ{dOmikZfP* zSO=Ht2B!rq0fo%u1*@x}~kJ{m5^x7A`K%1n_eL zlp2&e2f$CKOvHWaYj2wF|Ho(k_OGo|{W1LHVfqCbjRk5SE?+gWDReE@I(~dCd*;7c z)EmN{b?x(f1M<1LNwo)bpN_iRF3aQ#aNO&u>KO!jbD1tKa3#r85(ep$U4uN&fQ*x1 znt=*5o3!1~^n(G5%BDj^&)5R%Q=o6xkI7#Dy)4Ze!_o!^7v&{jsrFpJa3IcbTTlg% z26A3z16~UG{%Uvf4@5~vfM(T<4@2A+G4BSw0BP2YK{hAEed1RQz%L*8PjLh!W5W&B zHw=x{1u*59DjNoX7HWRk*bXS}Zh~S>4a-e+`@UFoD-ov&| zo^0@%3Kw`TfZXi7-#Zm#p5BVP@X4Zu@PF)`cYGAp+JK)kTe8Wf7m|=hLhrrz-itJ; zf(nWa6$>gNA}AdNK}A97AfQN*Do7PjdXwH;dfmP==lf$f>g9UxX8{ttJpY_uHnTJD zIWv3ayzhAn1dFEl0!E_I0SbP9P~q_W{&kozfL7gE(R~dZ)5U81!DjRQNZ%9WS#2y) zK(QG zE!^;QY%6g1g?AiW9Mn9Yy`^3Ro|lWXu7FuyR{MM9yZxCPsE~n*w5Ou_SaR&6lJR^88=;sCy@-~Rql+Madkh$`Bp;!DpF8?WV6^I^6 zcf$lw{EgKk9s}{M$kNvaX_cAs<=-5Cr_p(`i0k?&QNjqxwzM|Z$6#sv>J?{xgjI_- z{(Qb6TzcYKa&A+wuD4BbJrA;j9LOs03-EYzLg#dvN2mosfEA zZ^es8!M;0rTJA8=vR#TA3xvp#Tmf#N;~MZZS1Agjw0!JO@hoUL+9F#;kV~}Lt`&fhNYTUly~43&^ngEs+$Gm=6ZGBnhsE1a zGpzIVqG#c9_XE#n)&$ENH{Q0cge-@ZrX-YG&Ep&BpCxWqxu8gu8 zlpmE3l=dLM^Zb7GMYT5C*HCh8Rv&9iNV)F&j88Riw9-{ol7Ls`A@BRCaLmF}nJ#96 zb+>h=wI`$uPo9%p9{fM^ukT+OGM>$?XxE_h))IXa20#m?=BXqDEZDKJ#<52MDXxgc z1>T$6R+RN-dD;f$J#Bt05BWI)3Qd)OLT3Q@eOeaxv=wID_KyO)?eZeG$Oc_=OQtQykUlL0V;={3j{?x07!O@Vffv@AyZ46Y;ruJR}FC_OiGj^6QA%|5Jv5 zGvwj|pHIb4;%hMWHty5C1BUGZC4IUBi3}&dW=hoWp20H{G*sZIf)BydF zz*u7_=mwaN8jPTQ?3k;53))2MH_rW_CD@y3MM37dJIYbOhguVMf!r_4aura?`P~J* z@D|`oVJ8Q4O9@hcxo2UqoFND2IP4N4u+=uRgU`!|#s!A}`E-u_VK;I$k zX)PVZVqK>E2IR|HpePOUNo_5~0nHl(;l~a6GRQ&7246ck4Z(xDzXNJ3p9-Z;0p;X) z^%FpFg)FaxfA4K0&;fe#VAW=cSEaFTbgZqkK&+37oeq+iivl{f5Ea7|7 z!7wy?>e?}&#JeXXw*h&LPReJ1h7oTHqI;wec*Y@}z4BWSFN!wGe9-stuMu1V^fmp< zhFk~HU-*lIAai6z_ISTnn165iW!Q{Fi#{Og>oY^o0V9p>9mSLT0&cR&#WS1u-=#5nz}+K1IpAik z8P7qHSL1{I20+D~Z6l&~z}_Wa9KLuO)S}YGTaYrtndcq={^N8$#utH!T8uUo>~8mH zwJrFaFxr$1z~C(tXckY1HW2o${Viv2h#iqP(7qeay%wbR>kPt;;36KCwJ;cvOrE5M z%w`s!z^ytr-@aKMB7LKRqK`nzsmvulp%7*ctQr0)bgtRt%}R}7eT_X|om&d&7jj>> zj{>E*I4wpObZ7EM)Ewh!dp+lAH<$9X>LUd$;O!KeSMu-g{QD(&+TO=Jtv=5CkAjPe z%#Z1*sV$XNA>ql$v4M%u`tkbfDwF`n33ZOLAJUd)jkT4A981pXoVAeVllDw%C19)= z$Akit{`c@awAVdl(ZpNwQ9gjAIXPxq1u!pi%~Y>~>>*lhzM>#VJmUqE^f*BbQ*$Y#RXvN1DdqT`zhJq-{n754akjHV%9@)U}_(W8*D4>pS#EX zT3#@}+~7YA*^3iof!}`JCLtlXi{B51YhcI;eBHDMD9>0r0NS7Ie=eSS*-h+^HHFKgzK*Gvy9m_up@ynx!$k!m@#iq|^w}3F8 z-frtp5U`={%Z_tkIA6rBEdjcUmpBb_f!0e@1oGI2k$m<07eqWOv{ssINvQ!*|OIxp%$axB0 z-8S~SUCZI8l}AQrl!xNQikB+h45C{{J0sVFa#q=;3@eWM{bz)F-tKav$7mo_sQI5%_7ontuQ9Wc9aVyDhojok5~u0~Ace zgD9>4H26&r%XEu<-v;bl@NSqqSTWtl$Xv2<0gs7LfXWFizm7ZuVV{>OA5a>kpB5#b zhTJ#R1)3AGdbr1^oq^`~V*qPJa)?h+1D+#9KnzkpSQx14&|qm zu9?^Y8t$t6Rs0^1J++lGhC5e9>F;sdFS7M}p0>Pi{wH2Nx6u4@3x3G{t2{M!dfEoF z3ys`XudCNHR3Zgh*Qxzd$zc$`Jg#WWL`VIQ;- zVfZOUfM4elDFKf_%+YQuE6j%S0fV~KutAgT>I;1Kz{6t#HeND7!q`Y3DUwvZ^%*Mb@l%(8cuG3h!xK(lRDYcac>Va;)I=x~QD#M{ zOek})%&9UPp~CqJ=PO)*)CEnCahzuPZQ40{<-f)LO*)Lm7Ez_Gla&!jyK z)6UGvJoFV<6YVwJ--7r=jHB6qk<-VUGa!+8g5lWkyz#E`aD3pE4cRY1O7;({FFL@z zBhTva1@WR%Tdc)nXe=}iuR#9%We}cZqrJpKQ~-5^_Mu!2H(Gdi{H0g%pZag*{H%9H z@&A{>23(}F7DN}NiQx?p9SqgNW`jr&Bb6Q8ze#-`;30n_F-AMcXApEOe67!GQ1wKo z4~xcw@H6&R`hlD%YcLm54bEQf&%pJpoG43xc1^CAsbJgZ8sx49avD200QjOu2QorD zDq2FwT1T)e9^%^MowC0O93X-qz+K34Yy}WNAkdgPvNqhRbMxg}iC}%qnr7Pw$zNw) zwxok`tSQ7i4?4fuq-4cMAh4AAF=IN&>T-xI_*?+D5#^ov{w>D4&=_9|T=lwb=ij>& z7o|OI&ugAGa7#hU`HO%bXz8*aM86-_((eFt7}V%`#k!#N5X<%LA?53=P1c!^_if(N zymOHDOzPg0aX@=I(Fsr0fC3+NApaq}YKuF5UNw$WAZ;ZQ+`Y_1nMFUX| zh$a9tXfMiQvNhP=aMg7O03XZQECfp(HCAf{8NJ<&wNk(Yd0c)5riNip`W%94pLZM? zJrfLTjN6p+AlJ+JTq)=wxG(V}0Slm(_#VU|eFOiQAY#Nb$|yX60T~4?;$0wrL0ghI zLO}@>hZzOpkeJJ(AWRt1eoiR%IP9Say|mP`deC)R%zZ%N47{R)WO7J-(>99IBUU+qdK#=x!`?RM`VPc7_M! zY=XF_^gHaOfI%`=J`D1NTtFV49kV~PkP&D&L0+Vi=Ru_E zzY44f(jjlkg?C>BC04m2QsMOD=T>L@0BbgWr@MFp*d&%Q1eD@Rf)WU#ooFZ8foLPz zh&CXuimT!(kVoDh@=P#!vSsVu*R>XL@ZC4N#MRAkaLw_clxd(mt|SV-|MLCiqCCN1 zxu`xNi^9PX8O`jSAi3Dj-zCon+q2jAWiWjYn~YN` z+N1JiD5KVG9j1fm$0`pEz7BG?7A=Q@)u=usABXg1t{~MHh$EN)a3r})s)xb7Or54_ zAnH<#7~q=MqxX3^M9zf7syTJ6?ZNL8*Qe@D;4#sRN2&-HkWn;u zuKfb!UAHZ9o`aN%$$gX4!QR5|YtIE<;WhC_fl2>+{Q*E05s%UWLN3{7xPE|`*DRmd zZNR&tx;JK4AV8EOig0kQbq`k~z*R+Uscr%J21_{xsq380)T!V?n<2}9_7TSkgVNWV zJyE0r#8fFcF<=nL4>e>@eu;&8z@NlTHv2&|5ZSs%K`d0>_pJb^WB!5TDk_L1 zB0x)(gQOnP_Gg!|Ss-VI<+QUF$o-t+CW!p9Ft>XIv^VwFzY38=tTme<*_qnLk_)!) z?91F!|2c*LnT`t$#7LSF0`bv)rSxkc#1wfZU?up3hWnd82A0ZTUcEDyL zFvbDS?AQJSxJ)FyIPH`q3KnRDW z@h_Y`lY?yWj-v&Xn}*S*Az)Y-(!NL*7$Sq#g#QRiF?|#Lqad%zm3#SYWjU4B|y{?r*sB9xhf9c#p`>^2Masrc@}>3JA5;FBBYE>b6DE}>*Zv5 z2F@)$xA@!=IDP8$sne(6WbKo+Pu7NuW6q0?$6@E% zef@9r1}e#xEaczI1m?T`hti%{xbc!BRqFv4e@r`Ry$U%kPX{MY0&SdoyEX}k5=}+P zdwVPY6e`!q1QDW(Qhovg#YQm{iZl%_W$FuIZG(H7z6GB4#`qV6;{UJm=5Y)}HL+KB z5R_{AeIcbl6cCYqc*|A@c+%LL^ZjU(=qILm+wJty#C4gLSp-1IH>z8I(2HQU}aW`d13r3mv;O z`n>#mV4CVvRX+seIJrdrRM4HcU9T>;#M3s5zU{aIANj&!0Ju%D&#$AH*!#BQ3NGni znCvV+f#5^tg+6Pc!^TE0RJaAoQ^wY&mXLZa^SE^ySUOv#SbZVoqvXrUp8!WV#38^3 zAO6b1>~3+9Kzu5mn=+58A zIJqU40WT`Me7XaJl<9^qKsx2EUtCrHNq85^tYRYF;LMb(=8Q*R?Umgn&X<7=*1a7r zgh5(Z_9wQ_K^VnPjQGv>^9=zty~zSwnR@A8f=IuJ&E_CTwxzbTWP@#^eTjQAh@ZTn z0rz>10GYs6u0zp}d>ZL?LQK7|7JlgvP(7(#cs&qriRU;5xUv3AS-?MVY9!z!3mb4q zj*x3W4%0@+7+}9#BHDuPRlnlK^AJ?C%I`s@=?78*EkAIt&Pq_&4U3` zO6+&ngl@A!f5?f4gztY2upe!(~GIj>Ti@_Tr%7S4-$h$=vg07|U zecxjsii!S=1g^76&cLI{=Kiky0v(7_e5mdLWwPV=*|9)F+133rpy5MdR$%fC0mbEP z%>rtFpP{8sfm+;rt!^3!GnZw4xxnAMuhM(}a^xBIgG^;7Ux6^|^!gw$j0ngHc@~V# zLPMjvgFem||9GGti^WBd>2eQiymA!y^5rj&pl9cQJg{6@<~Iq%NqsMWmv_f?+Ha1# zTO#=3iyl;=b(d@4+!vQV%&H9PaBYjc0b;CpM+}F&sd-cLroy?p=jxuT3pXp@tbDUF zXwPZSY0rU(6|o}rPh8lWb3l%ltLP6GYhB%w{XMwN>g!q?5M@P4LVhD>fG0Vpyvk{u zaG{^|rYj55D%^T6_Z_g+yV)>jCGfDwVj>=MVBy(Q{FM-bF#%m=NydRTL^oe)3C3kU zUG)JFFxV zy`gx~YV(6%g!s-ir-!x#?PaYEW58ZayC^q6dY0?FngX0h!3fUf>WgX+xSD7^wF4mP zkw^@X>Zzt9kTd1CP|P=Xjcq=dLtI1DT|ht4k}5!9^90x^z8Bjedt-L{>?FvXnvt6R zDP%sK`@B68@&-AEsyRG z_q3or0Se3j@cSJP*yd@wp7wt5zPBwnXEJYc3GJfRPv$_)m1RZIV^H}*xe`fpAbV`y zY3FgsUSJ7vm?14QwL;2nupYLKu{;5M!fY|8z@-0oyp}&%L_A7M2;FU;>pBQA&slsN zErDl5BP#sn@FcSY98`Wu=6EqVO*am6MolmKY!2PhiNk5SL#YHg;$_BOA z5t#->hR5~vTLE&5){>$8s?a^)uOV@f3SyE{-e(t3iFGv~VzNvjAD}#Jedqf6-?5RYbUOQ(V~apBIy+vi3!D>!6n{LS0``KwiT?#1 zc1{9E#TeaEa6jo+yrvCgdqwqo98Xfg=KvK4Rv?-0Qe!5j@Xz?%%!00}2{BM~>no7+afe z={|&NtvZZ|ZU=^_z(9irjFIv3Ye*mIQd9-(cI~{}4Dz(BBfEipovV+#EXb;IvYZP9 zc{Uzp74fiW2!RpK((Wq|_d?zt+aNseS15cr0m@OH3ZRu%LsdVx6>+P@%`0GQWMAWa z1yT=X?y!!9uoB^~gf)Wpruw4H9MFwYUQ}v;+%M0NT+p5P*Tlonz*{i5^2XbaE3lC- zXb*tfu3yU=m0I)m0w=mZbhf*IoFu=L`@s}%yr`=K?Z-D5QMN4jjWTx$a6@YGESu#c zupP2bu}_4Q?#Uk|w*+}pyC}~A!GsW6P}2VnSMkU6Ys`PKZMjd_o&}#1?(fxgAjeTn z6bBLrB?vTwye1>Sp5-3lZUOjmmeY{;ocnXl3E6MDBh@7!N6FE0JOq9k+r#fTRNB_! z<;W2ra>Zd9flT8@p?tC4KX_cN{U|GD0w3uf_8kPmEGmk5zZ~(8L)viQ241EQwV~vw zI4$%`h>weE7gPyKJ`a+qssZvGHdIg^6)%tg6^jKfFpPqj+#h`0Zz~wP z1x@gk;4?E!m?fA3qIw660dt+iS3~zg=;msD;^HAXwAG3-&7pXOhZj^I2^I8@MAj?= z^#^r5T`32;Y^z@^!UqP8DDjEY0DXrPIhgYURDaR$ZCevCyTw9nDrjHGZ)pT_9H~SD z`d^$AZ^xr}I>{s%u!<$Ef|aCOj-Ljh|OA#wFQtYnkXIc7)%SRAwU5l*s1LV z?NxoRBHx1Cq-z(t2gqWG_AH2KS~C!oclD1OZ-Jqw|G41uV2lr05%nV&o(b3$QW=yz zhT=XcfDRu_AT#BmKjT_{-{9niTmWL2vd5<%h;zE<{o4aBnJzbbkGU7iF*^=a(0!n5 zqr^c}R*|0Or+~>~Bn`NGS*`QUH&?h$E|^#Njxj6*-9tKy@*;3R9wX&9htCsb2?9$K zt)&!@y3u;oRRipa>8C9!NV{s04FID@(JnOPEB0|8DtBK}k@oXq~-bDriIHOy+_kT1%9dAU)l6R!src;Y0_{aCN!X7+i^3 z3vKIfJOQ#iIg&)W{9JB^V*PSmwiDnt!8KP+rSRqi_)>huO2`_Ssb(I8obc>#vfqb{ z?YSjw^}w;;J(#DU$v3r1mbE}agUBxf7K5xOm&@uDGIMpEUo5>FENdLg)ryeyecnoYQ^>rP z(K^EdIa71W7Z!$}RQ}F?oOpz05IoJ1;4T9(&st3O*1&L4_m}$Mcz6DT z!11AbkZJ(8RM%-mK|9NvY=G1cTyLqXKwT?Uo(35vriibh+=UjsA|oNJeo;(QL7vuL z;7xu>cJhF~h=!f3AQHv9$~h22#23cHcsv3M>w@JDA}h-Qd=Alb!hFpiL)(LO+9$Pz zroF0ePv{8#X})y~b3k^Hud(6}oG{-IP|F({(9twNKO7>h5zEX*NDfHtWpRV;Yy0f` z(h!iJ<72&C%0-Bs=M$xy1J#>ERWiQ>rB}APSY|qudv4(OwNs!}i~g_GEDoj0^{ZLa z4W%zUQl{n@s5o@sYqiTmwGsm!s$Bx=)aa#DeG*y@>$s`>%h01oN9J_m71 zc|q3(^pnj^0{4TlTIh|aC@|IuwMJJ0z0>?w@av$=F?{LM8mKM|NlTLjJRh^XM1SBhWuu=7WR@W}xBw}b19yT3Lb6e;$JT+kQQk5*m*(-UC_%+Eof;&WMl4SXvr z&xu>{58`%TxY?j|6sc|8FFyq*A+y`BIM zJI(Hc5LeIA+WtLolrRDTwUDjT+tW#O2AAgi*|iUnQ*VXeS`L;ewk6JDkZ#DCW6Oj1 zNwHbck3h3Gs?SZ@0`ef=$z_1WTeYoVxoySJ!D}jwDv|$5L4^YRoqWN6iQn&N!dXw- zs?bbf@;ukc0_9sVTP%TA6Kd5h`8kC9g|7{J6fT=mS6So0y3jtyc@UCMC-=N%2eqNP zRV@a>C3M2TuQ8VeO)|b1LHR;H!c-`BEO(Q2GnhuZUsHoX28i>b6u)E_)yhblED829 z?oZv_fU|^g4)TV&7ik*gOm%NiH-UUr4wpF)G&CW>oC+1XH2o}M0EkcMO(*Y&X_>_NG;Zad8_W2s0=}G z>PIW1z&u4)M3jTTV)~9E1ALl_Z^TScW{TG-4%Ejkc7S%mb=6QGRI9uqVgWZ-C<17A z&6`UiLFRCZ9|7c2egxqwqLoC@MVgxW?gHh!&m7-3fZ1BKdk$#jonsyQLF?)qYO4xL zx^wHUP9Sb&=Gvx#(;7IqV=+xTf0-rl5%C{vSeAZ@=~W(O^nfE{VCoHhBqupl2agr!^2p zQB?E?YU|GVZv|0Je3ws#3m?Az-y#mew>Q1c-xQc4awaH+tt1G4}3UU*txdfu7 zd|NJtguc0}tif<4)xVPI9N1pc*VCl~AIM#t1Pc1CkiUc9OZ1~3r1eRgmG%w99<>~@ z^n^6OtZk+`5Lqu|d_+ZPeW~8*awTA8;`XP0J`9-|dC89VK=_H{;;jPg#lKM2Q!j^x zpL*Km`2|?>>kr+t>>~xWbiJ+6Qgd(2f6~kXlIP!$uWRSzLr`>ISVQwG&}?O$u4OBO zbChON_CxyWoN!xN$X%J+Gq)jRR?YY(a}r*+=o5m2d&UwwX24Wu1 zn`hU61(YV{*MmiAiVz0QZ1*g+8n{!`6

r3gg%csoAbi)a{_|lLm%@j28>Uw@~)Q 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

IuGE8%CV;Km8wUfTTX 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

}mqFVfVm>dUj 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 { + if (this.window.isVisible()) { + this.window.hide(); + } else { + this.window.show(); + this.window.focus(); + } + }); + + this.rebuildMenu(); + } + + updateStatus(status: Partial): void { + Object.assign(this.status, status); + this.updateIcon(); + this.rebuildMenu(); + } + + private getOverallHealth(): ServiceHealth { + const { server, runner, redis } = this.status; + if (server === "error" || redis === "disconnected") return "error"; + if (server === "starting" || runner === "starting") return "degraded"; + if (server === "running" && runner === "running" && redis === "connected") return "healthy"; + return "degraded"; + } + + private updateIcon(): void { + const health = this.getOverallHealth(); + const iconName = + health === "error" ? "tray-error.png" : + health === "degraded" ? "tray-warning.png" : + "tray-default.png"; + + const iconPath = join(__dirname, "..", "..", "assets", iconName); + const icon = nativeImage.createFromPath(iconPath).resize({ width: 22, height: 22 }); + icon.setTemplateImage(true); + this.tray.setImage(icon); + } + + private statusIcon(val: string): string { + if (val === "running" || val === "connected") return "\u2713"; + if (val === "starting") return "\u2026"; + return "\u2715"; + } + + private rebuildMenu(): void { + const menu = Menu.buildFromTemplate([ + { + label: this.window.isVisible() ? "Hide Window" : "Show Window", + click: () => { + if (this.window.isVisible()) { + this.window.hide(); + } else { + this.window.show(); + this.window.focus(); + } + }, + }, + { type: "separator" }, + { + label: `Server: localhost ${this.statusIcon(this.status.server)}`, + enabled: false, + }, + { + label: `Runner: ${this.status.runner} ${this.statusIcon(this.status.runner)}`, + enabled: false, + }, + { + label: `Redis: ${this.status.redis} ${this.statusIcon(this.status.redis)}`, + enabled: false, + }, + { type: "separator" }, + { + label: "Quit PizzaPi", + role: "quit", + }, + ]); + + this.tray.setContextMenu(menu); + } + + destroy(): void { + this.tray.destroy(); + } +} From 60ac6537f37e6a88e80b9a28446aed70b8f94b30 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:34:59 -0400 Subject: [PATCH 10/20] feat(desktop): add IPC handlers and preload bridge --- packages/desktop/src/main/ipc.ts | 27 +++++++++++++++++++++++++++ packages/desktop/src/preload/index.ts | 25 +++++++++++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 packages/desktop/src/main/ipc.ts create mode 100644 packages/desktop/src/preload/index.ts diff --git a/packages/desktop/src/main/ipc.ts b/packages/desktop/src/main/ipc.ts new file mode 100644 index 000000000..3a4f77888 --- /dev/null +++ b/packages/desktop/src/main/ipc.ts @@ -0,0 +1,27 @@ +// packages/desktop/src/main/ipc.ts +import { ipcMain, type BrowserWindow } from "electron"; +import { app } from "electron"; +import { getAutoLaunchEnabled, setAutoLaunchEnabled } from "./auto-launch.js"; +import type { TrayStatus } from "./tray.js"; +import log from "./logger.js"; + +/** + * Register all IPC handlers. Call once at app startup. + */ +export function registerIpcHandlers(): void { + ipcMain.handle("desktop:getVersion", () => app.getVersion()); + ipcMain.handle("desktop:getPlatform", () => process.platform); + ipcMain.handle("desktop:getAutoLaunch", () => getAutoLaunchEnabled()); + ipcMain.handle("desktop:setAutoLaunch", (_event, enabled: boolean) => { + setAutoLaunchEnabled(enabled); + }); + + log.info("IPC handlers registered"); +} + +/** + * Send service status update to all renderer windows. + */ +export function sendServiceStatus(window: BrowserWindow, status: TrayStatus): void { + window.webContents.send("desktop:serviceStatus", status); +} diff --git a/packages/desktop/src/preload/index.ts b/packages/desktop/src/preload/index.ts new file mode 100644 index 000000000..b201de094 --- /dev/null +++ b/packages/desktop/src/preload/index.ts @@ -0,0 +1,25 @@ +// packages/desktop/src/preload/index.ts +import { contextBridge, ipcRenderer } from "electron"; + +export interface DesktopAPI { + getVersion(): Promise; + getPlatform(): Promise; + getAutoLaunch(): Promise; + setAutoLaunch(enabled: boolean): Promise; + onServiceStatus(callback: (status: any) => void): () => void; +} + +const desktopAPI: DesktopAPI = { + getVersion: () => ipcRenderer.invoke("desktop:getVersion"), + getPlatform: () => ipcRenderer.invoke("desktop:getPlatform"), + getAutoLaunch: () => ipcRenderer.invoke("desktop:getAutoLaunch"), + setAutoLaunch: (enabled) => ipcRenderer.invoke("desktop:setAutoLaunch", enabled), + onServiceStatus: (callback) => { + const handler = (_event: any, status: any) => callback(status); + ipcRenderer.on("desktop:serviceStatus", handler); + // Return cleanup function + return () => ipcRenderer.removeListener("desktop:serviceStatus", handler); + }, +}; + +contextBridge.exposeInMainWorld("desktopAPI", desktopAPI); From f83fa481cc6012cd7606ff820e9474230ea95383 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:37:40 -0400 Subject: [PATCH 11/20] feat(desktop): add main process entry with full lifecycle orchestration --- packages/desktop/src/main/index.ts | 189 +++++++++++++++++++++++++++++ 1 file changed, 189 insertions(+) create mode 100644 packages/desktop/src/main/index.ts diff --git a/packages/desktop/src/main/index.ts b/packages/desktop/src/main/index.ts new file mode 100644 index 000000000..726bd33cc --- /dev/null +++ b/packages/desktop/src/main/index.ts @@ -0,0 +1,189 @@ +// packages/desktop/src/main/index.ts +import { app, BrowserWindow, dialog } from "electron"; +import { join } from "node:path"; +import { ServerManager } from "./server-manager.js"; +import { RunnerManager } from "./runner-manager.js"; +import { AppTray } from "./tray.js"; +import { registerIpcHandlers, sendServiceStatus } from "./ipc.js"; +import { notifyServiceError } from "./notifications.js"; +import { isDev, DEFAULT_SERVER_PORT, VITE_DEV_URL, getUIDistPath } from "./config.js"; +import log from "./logger.js"; + +let mainWindow: BrowserWindow | null = null; +let tray: AppTray | null = null; +let serverManager: ServerManager | null = null; +let runnerManager: RunnerManager | null = null; + +function createWindow(): BrowserWindow { + const win = new BrowserWindow({ + width: 1280, + height: 800, + minWidth: 800, + minHeight: 600, + title: "PizzaPi", + titleBarStyle: "hiddenInset", + trafficLightPosition: { x: 16, y: 16 }, + webPreferences: { + preload: join(__dirname, "..", "preload", "index.js"), + contextIsolation: true, + nodeIntegration: false, + }, + }); + + // Hide instead of close (app lives in tray) + win.on("close", (event) => { + if (!isQuitting) { + event.preventDefault(); + win.hide(); + } + }); + + return win; +} + +async function checkRedis(): Promise { + try { + // Quick TCP connect check to default Redis port + const net = await import("node:net"); + return new Promise((resolve) => { + const socket = net.createConnection({ port: 6379, host: "127.0.0.1" }); + socket.on("connect", () => { + socket.destroy(); + resolve(true); + }); + socket.on("error", () => { + resolve(false); + }); + socket.setTimeout(2000, () => { + socket.destroy(); + resolve(false); + }); + }); + } catch { + return false; + } +} + +async function startServices(): Promise { + if (!mainWindow) return; + + // Check Redis first + tray?.updateStatus({ redis: "disconnected", server: "starting" }); + + const redisAvailable = await checkRedis(); + if (!redisAvailable) { + tray?.updateStatus({ redis: "disconnected" }); + notifyServiceError(mainWindow, "Redis is not available. Please start Redis and relaunch."); + dialog.showErrorBox( + "Redis Required", + "PizzaPi requires Redis to be running.\n\nInstall with: brew install redis\nStart with: redis-server\n\nPlease start Redis and relaunch PizzaPi." + ); + return; + } + + tray?.updateStatus({ redis: "connected" }); + + // Start relay server + serverManager = new ServerManager({ port: DEFAULT_SERVER_PORT, isDev }); + tray?.updateStatus({ server: "starting" }); + + try { + await serverManager.start(); + tray?.updateStatus({ server: "running" }); + if (mainWindow) { + sendServiceStatus(mainWindow, { + server: "running", + runner: "starting", + redis: "connected", + }); + } + } catch (err) { + log.error("Failed to start server:", err); + tray?.updateStatus({ server: "error" }); + notifyServiceError(mainWindow!, `Server failed to start: ${err}`); + return; + } + + // Start runner daemon + runnerManager = new RunnerManager({ serverPort: DEFAULT_SERVER_PORT, isDev }); + tray?.updateStatus({ runner: "starting" }); + runnerManager.start(); + tray?.updateStatus({ runner: "running" }); + + if (mainWindow) { + sendServiceStatus(mainWindow, { + server: "running", + runner: "running", + redis: "connected", + }); + } + + // Load the UI + if (isDev) { + await mainWindow!.loadURL(VITE_DEV_URL); + mainWindow!.webContents.openDevTools(); + } else { + const uiPath = getUIDistPath(); + await mainWindow!.loadFile(join(uiPath, "index.html")); + } +} + +async function shutdown(): Promise { + log.info("Shutting down..."); + + if (runnerManager) { + runnerManager.stop(); + // Wait briefly for graceful shutdown + await new Promise((r) => setTimeout(r, 2000)); + runnerManager.forceKill(); + } + + if (serverManager) { + serverManager.stop(); + await new Promise((r) => setTimeout(r, 2000)); + serverManager.forceKill(); + } + + tray?.destroy(); +} + +// ── App lifecycle ───────────────────────────────────────────────────────────── + +// Track whether the app is in the process of quitting +let isQuitting = false; + +app.on("before-quit", () => { + isQuitting = true; +}); + +app.whenReady().then(async () => { + log.info(`PizzaPi Desktop starting (dev=${isDev})...`); + + registerIpcHandlers(); + + mainWindow = createWindow(); + tray = new AppTray(mainWindow); + + await startServices(); +}); + +app.on("will-quit", async (event) => { + event.preventDefault(); + await shutdown(); + app.exit(0); +}); + +app.on("window-all-closed", () => { + // On macOS, don't quit when all windows are closed (app lives in tray) + if (process.platform !== "darwin") { + app.quit(); + } +}); + +app.on("activate", () => { + // On macOS, re-show the window when dock icon is clicked + if (mainWindow) { + mainWindow.show(); + mainWindow.focus(); + } +}); From fd3f8d223c2ac149dfb42bcdf3d940892baf4138 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:41:26 -0400 Subject: [PATCH 12/20] fix(desktop): fix test mocks to include all config exports --- packages/desktop/tests/runner-manager.test.ts | 6 +++++- packages/desktop/tests/server-manager.test.ts | 7 ++++++- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/packages/desktop/tests/runner-manager.test.ts b/packages/desktop/tests/runner-manager.test.ts index bde9f36d1..4abf23f35 100644 --- a/packages/desktop/tests/runner-manager.test.ts +++ b/packages/desktop/tests/runner-manager.test.ts @@ -21,10 +21,14 @@ mock.module("electron", () => ({ }, })); -// Mock config to avoid __dirname issues in test +// Mock config to avoid electron dependency in test mock.module("../src/main/config.js", () => ({ getRunnerEntryPath: () => "/fake/runner/index.js", + getServerEntryPath: () => "/fake/server/index.ts", MAX_RESTART_ATTEMPTS: 3, + HEALTH_CHECK_INTERVAL: 10, + HEALTH_CHECK_TIMEOUT: 1000, + isDev: true, })); const mockKill = mock(() => true); diff --git a/packages/desktop/tests/server-manager.test.ts b/packages/desktop/tests/server-manager.test.ts index 660852887..d4ba09374 100644 --- a/packages/desktop/tests/server-manager.test.ts +++ b/packages/desktop/tests/server-manager.test.ts @@ -24,12 +24,17 @@ mock.module("electron", () => ({ }, })); -// Mock config to avoid __dirname issues in test context +// Mock config to avoid electron dependency in test context. +// Include ALL exports — bun test shares modules across files in the same run. mock.module("../src/main/config.js", () => ({ getServerEntryPath: () => "/fake/server/index.ts", + getRunnerEntryPath: () => "/fake/runner/index.js", + getUIDistPath: () => "/fake/ui/dist", HEALTH_CHECK_INTERVAL: 10, HEALTH_CHECK_TIMEOUT: 1000, MAX_RESTART_ATTEMPTS: 3, + DEFAULT_SERVER_PORT: 3001, + VITE_DEV_URL: "http://localhost:5173", isDev: true, })); From 5cf3db5b952790670d4e2655428e1b917a06a99b Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:44:24 -0400 Subject: [PATCH 13/20] =?UTF-8?q?fix(desktop):=20fix=20ESM=20compatibility?= =?UTF-8?q?=20=E2=80=94=20use=20import.meta=20for=20=5F=5Fdirname,=20add?= =?UTF-8?q?=20.js=20extension=20to=20electron-log=20import?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- packages/desktop/src/main/config.ts | 6 +++++- packages/desktop/src/main/index.ts | 6 +++++- packages/desktop/src/main/logger.ts | 2 +- packages/desktop/src/main/tray.ts | 6 +++++- 4 files changed, 16 insertions(+), 4 deletions(-) diff --git a/packages/desktop/src/main/config.ts b/packages/desktop/src/main/config.ts index 0758cf2b0..40a607701 100644 --- a/packages/desktop/src/main/config.ts +++ b/packages/desktop/src/main/config.ts @@ -1,5 +1,9 @@ import { app } from "electron"; -import { join } from "node:path"; +import { join, dirname } from "node:path"; +import { fileURLToPath } from "node:url"; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); /** Whether we're running in dev mode (passed via --dev flag). */ export const isDev = process.argv.includes("--dev"); diff --git a/packages/desktop/src/main/index.ts b/packages/desktop/src/main/index.ts index 726bd33cc..6686f86e3 100644 --- a/packages/desktop/src/main/index.ts +++ b/packages/desktop/src/main/index.ts @@ -1,6 +1,10 @@ // packages/desktop/src/main/index.ts import { app, BrowserWindow, dialog } from "electron"; -import { join } from "node:path"; +import { join, dirname } from "node:path"; +import { fileURLToPath } from "node:url"; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); import { ServerManager } from "./server-manager.js"; import { RunnerManager } from "./runner-manager.js"; import { AppTray } from "./tray.js"; diff --git a/packages/desktop/src/main/logger.ts b/packages/desktop/src/main/logger.ts index 9e20dea27..4e0cd5517 100644 --- a/packages/desktop/src/main/logger.ts +++ b/packages/desktop/src/main/logger.ts @@ -1,4 +1,4 @@ -import log from "electron-log/main"; +import log from "electron-log/main.js"; log.initialize(); log.transports.file.level = "info"; diff --git a/packages/desktop/src/main/tray.ts b/packages/desktop/src/main/tray.ts index e9c837da3..10c90b1f6 100644 --- a/packages/desktop/src/main/tray.ts +++ b/packages/desktop/src/main/tray.ts @@ -1,6 +1,10 @@ // packages/desktop/src/main/tray.ts import { Tray, Menu, nativeImage, type BrowserWindow } from "electron"; -import { join } from "node:path"; +import { join, dirname } from "node:path"; +import { fileURLToPath } from "node:url"; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); import log from "./logger.js"; export type ServiceHealth = "healthy" | "degraded" | "error"; From 6a42f12e2ebe65dc09980f9c3645ef79ebc23f60 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:48:24 -0400 Subject: [PATCH 14/20] fix(desktop): add port-in-use detection, auto-port fallback, Vite dev server fallback, and early-exit detection in health check --- packages/desktop/src/main/index.ts | 65 +++++++++++++++------ packages/desktop/src/main/server-manager.ts | 35 ++++++++++- 2 files changed, 80 insertions(+), 20 deletions(-) diff --git a/packages/desktop/src/main/index.ts b/packages/desktop/src/main/index.ts index 6686f86e3..dd4dea91e 100644 --- a/packages/desktop/src/main/index.ts +++ b/packages/desktop/src/main/index.ts @@ -87,29 +87,49 @@ async function startServices(): Promise { tray?.updateStatus({ redis: "connected" }); - // Start relay server - serverManager = new ServerManager({ port: DEFAULT_SERVER_PORT, isDev }); + // Start relay server — try ports 3001-3010 + let serverPort = DEFAULT_SERVER_PORT; tray?.updateStatus({ server: "starting" }); - try { - await serverManager.start(); - tray?.updateStatus({ server: "running" }); - if (mainWindow) { - sendServiceStatus(mainWindow, { - server: "running", - runner: "starting", - redis: "connected", - }); + let serverStarted = false; + for (let port = DEFAULT_SERVER_PORT; port < DEFAULT_SERVER_PORT + 10; port++) { + serverManager = new ServerManager({ port, isDev }); + try { + await serverManager.start(); + serverPort = port; + serverStarted = true; + break; + } catch (err) { + const msg = String(err); + if (msg.includes("already in use") && port < DEFAULT_SERVER_PORT + 9) { + log.warn(`Port ${port} in use, trying ${port + 1}...`); + continue; + } + log.error("Failed to start server:", err); + tray?.updateStatus({ server: "error" }); + notifyServiceError(mainWindow!, `Server failed to start: ${err}`); + return; } - } catch (err) { - log.error("Failed to start server:", err); + } + + if (!serverStarted) { tray?.updateStatus({ server: "error" }); - notifyServiceError(mainWindow!, `Server failed to start: ${err}`); + notifyServiceError(mainWindow!, "Could not find an available port for the server."); return; } + log.info(`Server started on port ${serverPort}`); + tray?.updateStatus({ server: "running" }); + if (mainWindow) { + sendServiceStatus(mainWindow, { + server: "running", + runner: "starting", + redis: "connected", + }); + } + // Start runner daemon - runnerManager = new RunnerManager({ serverPort: DEFAULT_SERVER_PORT, isDev }); + runnerManager = new RunnerManager({ serverPort, isDev }); tray?.updateStatus({ runner: "starting" }); runnerManager.start(); tray?.updateStatus({ runner: "running" }); @@ -124,8 +144,19 @@ async function startServices(): Promise { // Load the UI if (isDev) { - await mainWindow!.loadURL(VITE_DEV_URL); - mainWindow!.webContents.openDevTools(); + try { + // Try Vite dev server first (for HMR) + await mainWindow!.loadURL(VITE_DEV_URL); + mainWindow!.webContents.openDevTools(); + } catch { + // Vite not running — fall back to built UI assets or server URL + log.warn("Vite dev server not available, falling back to relay server UI"); + try { + await mainWindow!.loadURL(`http://localhost:${serverPort}`); + } catch (err) { + log.error("Failed to load UI:", err); + } + } } else { const uiPath = getUIDistPath(); await mainWindow!.loadFile(join(uiPath, "index.html")); diff --git a/packages/desktop/src/main/server-manager.ts b/packages/desktop/src/main/server-manager.ts index 2dc89a3cb..38f019fdc 100644 --- a/packages/desktop/src/main/server-manager.ts +++ b/packages/desktop/src/main/server-manager.ts @@ -27,6 +27,13 @@ export class ServerManager { /** Spawn the relay server and wait for it to become healthy. */ async start(): Promise { this.stopping = false; + + // Check if port is available before spawning + const portFree = await this.isPortFree(this.port); + if (!portFree) { + throw new Error(`Port ${this.port} is already in use. Stop the existing server or use a different port.`); + } + const entry = getServerEntryPath(); log.info(`Starting relay server on port ${this.port}...`); @@ -36,6 +43,10 @@ export class ServerManager { NODE_ENV: this.isDev ? "development" : "production", }; + // Track if the child exits early (before health check passes) + let earlyExit = false; + let earlyExitCode: number | null = null; + this.child = spawn("bun", ["run", entry], { env, stdio: ["ignore", "pipe", "pipe"], @@ -51,6 +62,8 @@ export class ServerManager { this.child.on("exit", (code, signal) => { log.info(`Server exited: code=${code} signal=${signal}`); + earlyExit = true; + earlyExitCode = code; this.child = null; if (!this.stopping && this.restartCount < MAX_RESTART_ATTEMPTS) { this.restartCount++; @@ -59,15 +72,31 @@ export class ServerManager { } }); - await this.waitForHealthy(); + await this.waitForHealthy(() => earlyExit); this.restartCount = 0; log.info(`Relay server healthy on port ${this.port}`); } - /** Poll /health until 200 or timeout. */ - private async waitForHealthy(): Promise { + /** Check if a port is free. */ + private async isPortFree(port: number): Promise { + const net = await import("node:net"); + return new Promise((resolve) => { + const server = net.createServer(); + server.once("error", () => resolve(false)); + server.once("listening", () => { + server.close(() => resolve(true)); + }); + server.listen(port, "127.0.0.1"); + }); + } + + /** Poll /health until 200 or timeout, aborting if the child exits early. */ + private async waitForHealthy(hasExited: () => boolean): Promise { const deadline = Date.now() + HEALTH_CHECK_TIMEOUT; while (Date.now() < deadline) { + if (hasExited()) { + throw new Error("Server process exited before becoming healthy"); + } try { const res = await fetch(`http://localhost:${this.port}/health`); if (res.ok) return; From 82b653c5c82ecc1b722b84b6a44c07cac24dd8a8 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:54:25 -0400 Subject: [PATCH 15/20] fix(desktop): suppress EPIPE uncaught exceptions from electron-log console transport --- packages/desktop/src/main/index.ts | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/packages/desktop/src/main/index.ts b/packages/desktop/src/main/index.ts index dd4dea91e..b3ec00adf 100644 --- a/packages/desktop/src/main/index.ts +++ b/packages/desktop/src/main/index.ts @@ -13,6 +13,18 @@ import { notifyServiceError } from "./notifications.js"; import { isDev, DEFAULT_SERVER_PORT, VITE_DEV_URL, getUIDistPath } from "./config.js"; import log from "./logger.js"; +// ── Suppress EPIPE errors ──────────────────────────────────────────────────── +// electron-log writes to stdout/stderr via console transports. When child +// processes (server, runner) exit, their piped streams close and the next +// console.warn/log call triggers an EPIPE. This is harmless — swallow it +// so Electron doesn't show the ugly crash dialog. +process.on("uncaughtException", (err: Error) => { + const code = (err as NodeJS.ErrnoException).code; + if (code === "EPIPE") return; // silently ignore + // For anything else, log and show the default dialog + log.error("Uncaught exception:", err); +}); + let mainWindow: BrowserWindow | null = null; let tray: AppTray | null = null; let serverManager: ServerManager | null = null; From a97815661bf3048caef96f34a16271a67f9f1048 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Tue, 31 Mar 2026 22:56:05 -0400 Subject: [PATCH 16/20] feat(desktop): add draggable title bar region via injected CSS --- packages/desktop/src/main/index.ts | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/packages/desktop/src/main/index.ts b/packages/desktop/src/main/index.ts index b3ec00adf..ee95fda20 100644 --- a/packages/desktop/src/main/index.ts +++ b/packages/desktop/src/main/index.ts @@ -46,6 +46,32 @@ function createWindow(): BrowserWindow { }, }); + // Make the top of the page draggable (window title bar region). + // Inject CSS after every page load so the user can drag the window + // from the top bar area, just like a native macOS app. + win.webContents.on("did-finish-load", () => { + win.webContents.insertCSS(` + /* Draggable title bar region for Electron */ + body::before { + content: ''; + display: block; + position: fixed; + top: 0; + left: 0; + right: 0; + height: 38px; + -webkit-app-region: drag; + z-index: 99999; + pointer-events: auto; + } + /* Make interactive elements within the title bar area clickable */ + button, a, input, select, textarea, [role="button"], [role="menuitem"], + [data-radix-collection-item], [cmdk-input], [cmdk-item] { + -webkit-app-region: no-drag; + } + `); + }); + // Hide instead of close (app lives in tray) win.on("close", (event) => { if (!isQuitting) { From 1118571e039bc32294733c28ea4b7f89c4692f0e Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Wed, 1 Apr 2026 12:29:14 -0400 Subject: [PATCH 17/20] =?UTF-8?q?fix:=20address=20PR=20#431=20review=20fee?= =?UTF-8?q?dback=20(P0=E2=80=93P2)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit P0: Fix asar paths — use app.getAppPath() instead of process.resourcesPath/app/ which doesn't resolve correctly inside app.asar packaging P0: Handle missing Bun — getBunPath() checks well-known install locations (~/.bun/bin, /usr/local/bin, /opt/homebrew/bin), falls back to `which bun`, and throws a descriptive error with install instructions if not found P1: uncaughtException handler now calls process.exit(1) for non-EPIPE errors instead of silently swallowing them P1: Fix auto-restart race during initial startup — disable auto-restart while start() is running so the promise rejects cleanly without a background restart competing with error handling P1: Tests use randomized ephemeral ports instead of hardcoded 3001 P1: Add packages/desktop to root tsconfig references and test script P2: Type IPC boundary — replace `any` with ServiceStatus interface shared between main/preload/renderer via shared/types.ts P2: Runner marked running only after readiness check — start() now polls /api/runners until the daemon registers, with timeout fallback --- package.json | 2 +- packages/desktop/src/main/config.ts | 51 ++++++++++++++++-- packages/desktop/src/main/index.ts | 13 +++-- packages/desktop/src/main/runner-manager.ts | 52 +++++++++++++++++-- packages/desktop/src/main/server-manager.ts | 11 +++- packages/desktop/src/main/tray.ts | 8 ++- packages/desktop/src/preload/index.ts | 7 +-- packages/desktop/src/shared/types.ts | 11 ++++ packages/desktop/tests/runner-manager.test.ts | 29 +++++++++-- packages/desktop/tests/server-manager.test.ts | 7 ++- tsconfig.json | 3 +- 11 files changed, 165 insertions(+), 29 deletions(-) create mode 100644 packages/desktop/src/shared/types.ts diff --git a/package.json b/package.json index 41b712f7a..864d23646 100644 --- a/package.json +++ b/package.json @@ -34,7 +34,7 @@ "build:desktop": "bun run build:ui && bun run build:server && bun run build:cli && cd packages/desktop && bun run build", "package:desktop": "bun run build:desktop && cd packages/desktop && bun run package", "dev:runner": "bun packages/cli/src/index.ts runner", - "test": "bun test packages/protocol/src packages/tunnel/src packages/server/src packages/server/tests packages/tools/src && cd packages/cli && bun test src && cd ../ui && bun test src", + "test": "bun test packages/protocol/src packages/tunnel/src packages/server/src packages/server/tests packages/tools/src packages/desktop/tests && cd packages/cli && bun test src && cd ../ui && bun test src", "typecheck": "bun packages/cli/scripts/compile-prompt.ts && tsc --build && bun run --cwd packages/protocol typecheck:tests && bun run --cwd packages/server typecheck:tests", "migrate": "cd packages/server && bun run migrate", "clean": "bun -e \"['protocol','tunnel','tools','server','ui','cli','docs'].forEach(p=>{require('fs').rmSync('packages/'+p+'/dist',{recursive:true,force:true});require('fs').rmSync('packages/'+p+'/tsconfig.tsbuildinfo',{force:true})})\"", diff --git a/packages/desktop/src/main/config.ts b/packages/desktop/src/main/config.ts index 40a607701..db79441d9 100644 --- a/packages/desktop/src/main/config.ts +++ b/packages/desktop/src/main/config.ts @@ -1,6 +1,8 @@ import { app } from "electron"; import { join, dirname } from "node:path"; import { fileURLToPath } from "node:url"; +import { existsSync } from "node:fs"; +import { execFileSync } from "node:child_process"; const __filename = fileURLToPath(import.meta.url); const __dirname = dirname(__filename); @@ -14,13 +16,20 @@ export const DEFAULT_SERVER_PORT = 3001; /** Vite dev server URL (used in dev mode only). */ export const VITE_DEV_URL = "http://localhost:5173"; +/** + * Root of the packaged app. Uses app.getAppPath() which correctly resolves + * inside app.asar when asar packaging is enabled. + */ +function getAppRoot(): string { + return app.getAppPath(); +} + /** Path to the bundled UI dist assets (production). */ export function getUIDistPath(): string { if (isDev) { return join(__dirname, "..", "..", "..", "ui", "dist"); } - // In packaged app, electron-builder places them at ui-dist/ - return join(process.resourcesPath, "app", "ui-dist"); + return join(getAppRoot(), "ui-dist"); } /** Path to the bundled server entry (production). */ @@ -28,7 +37,7 @@ export function getServerEntryPath(): string { if (isDev) { return join(__dirname, "..", "..", "..", "server", "src", "index.ts"); } - return join(process.resourcesPath, "app", "server-dist", "index.js"); + return join(getAppRoot(), "server-dist", "index.js"); } /** Path to the bundled CLI entry for runner (production). */ @@ -36,7 +45,41 @@ export function getRunnerEntryPath(): string { if (isDev) { return join(__dirname, "..", "..", "..", "cli", "src", "index.ts"); } - return join(process.resourcesPath, "app", "cli-dist", "index.js"); + return join(getAppRoot(), "cli-dist", "index.js"); +} + +/** + * Resolve the path to the Bun binary. Checks common locations and falls back + * to `which bun`. Throws a descriptive error if Bun is not found. + */ +export function getBunPath(): string { + // In dev, "bun" on PATH is fine + if (isDev) return "bun"; + + // Check well-known install locations + const candidates = [ + join(process.env.HOME ?? "", ".bun", "bin", "bun"), + "/usr/local/bin/bun", + "/opt/homebrew/bin/bun", + ]; + for (const p of candidates) { + if (existsSync(p)) return p; + } + + // Try `which bun` as a fallback + try { + const result = execFileSync("which", ["bun"], { encoding: "utf8", timeout: 3000 }); + const resolved = result.trim(); + if (resolved && existsSync(resolved)) return resolved; + } catch { + // which not available or bun not found + } + + throw new Error( + "Bun runtime not found. PizzaPi requires Bun to run the relay server and runner daemon.\n\n" + + "Install Bun: curl -fsSL https://bun.sh/install | bash\n\n" + + "Then relaunch PizzaPi.", + ); } /** App data directory. */ diff --git a/packages/desktop/src/main/index.ts b/packages/desktop/src/main/index.ts index ee95fda20..f84d1067d 100644 --- a/packages/desktop/src/main/index.ts +++ b/packages/desktop/src/main/index.ts @@ -21,8 +21,9 @@ import log from "./logger.js"; process.on("uncaughtException", (err: Error) => { const code = (err as NodeJS.ErrnoException).code; if (code === "EPIPE") return; // silently ignore - // For anything else, log and show the default dialog + // For anything else, log and exit to avoid running in a corrupted state log.error("Uncaught exception:", err); + process.exit(1); }); let mainWindow: BrowserWindow | null = null; @@ -169,8 +170,14 @@ async function startServices(): Promise { // Start runner daemon runnerManager = new RunnerManager({ serverPort, isDev }); tray?.updateStatus({ runner: "starting" }); - runnerManager.start(); - tray?.updateStatus({ runner: "running" }); + try { + await runnerManager.start(); + tray?.updateStatus({ runner: "running" }); + } catch (err) { + log.error("Failed to start runner:", err); + tray?.updateStatus({ runner: "error" }); + // Non-fatal — the UI can still load, runner may recover via auto-restart + } if (mainWindow) { sendServiceStatus(mainWindow, { diff --git a/packages/desktop/src/main/runner-manager.ts b/packages/desktop/src/main/runner-manager.ts index e3adac69a..b6fde2678 100644 --- a/packages/desktop/src/main/runner-manager.ts +++ b/packages/desktop/src/main/runner-manager.ts @@ -1,5 +1,5 @@ import { spawn, type ChildProcess } from "node:child_process"; -import { getRunnerEntryPath, MAX_RESTART_ATTEMPTS } from "./config.js"; +import { getRunnerEntryPath, getBunPath, MAX_RESTART_ATTEMPTS, HEALTH_CHECK_TIMEOUT } from "./config.js"; import log from "./logger.js"; export interface RunnerManagerOptions { @@ -19,18 +19,24 @@ export class RunnerManager { this.isDev = opts.isDev; } - /** Spawn the runner daemon. */ - start(): void { + /** + * Spawn the runner daemon and wait for it to register with the server. + * Polls /api/runners until the runner appears, or times out. + */ + async start(): Promise { this.stopping = false; const entry = getRunnerEntryPath(); log.info("Starting runner daemon..."); + let earlyExit = false; + const env = { ...process.env, PIZZAPI_SERVER_URL: `http://localhost:${this.serverPort}`, }; - this.child = spawn("bun", ["run", entry, "runner"], { + const bunPath = getBunPath(); + this.child = spawn(bunPath, ["run", entry, "runner"], { env, stdio: ["ignore", "pipe", "pipe"], }); @@ -45,13 +51,49 @@ export class RunnerManager { this.child.on("exit", (code, signal) => { log.info(`Runner exited: code=${code} signal=${signal}`); + earlyExit = true; this.child = null; if (!this.stopping && this.restartCount < MAX_RESTART_ATTEMPTS) { this.restartCount++; log.warn(`Restarting runner (attempt ${this.restartCount}/${MAX_RESTART_ATTEMPTS})...`); - this.start(); + this.start().catch((err) => log.error("Runner restart failed:", err)); } }); + + // Wait for the runner to register with the server (poll /api/runners) + await this.waitForReady(() => earlyExit); + log.info("Runner daemon is ready"); + } + + /** + * Poll the server's /api/runners endpoint until at least one runner + * appears, indicating the daemon has connected. Times out after + * HEALTH_CHECK_TIMEOUT ms. + */ + private async waitForReady(hasExited: () => boolean): Promise { + const deadline = Date.now() + HEALTH_CHECK_TIMEOUT; + while (Date.now() < deadline) { + if (hasExited()) { + throw new Error("Runner process exited before becoming ready"); + } + try { + const res = await fetch(`http://localhost:${this.serverPort}/api/runners`, { + headers: { "Content-Type": "application/json" }, + }); + if (res.ok) { + const body = await res.json() as any; + if (Array.isArray(body?.runners) && body.runners.length > 0) { + return; + } + } + } catch { + // Server not ready or runner not registered yet + } + await new Promise((r) => setTimeout(r, 500)); + } + // Don't throw — runner may still be starting up and will register soon. + // Just warn so the caller can mark it as running optimistically. + log.warn("Runner did not register within timeout, continuing..."); } /** Gracefully stop the runner. */ diff --git a/packages/desktop/src/main/server-manager.ts b/packages/desktop/src/main/server-manager.ts index 38f019fdc..52346e3ba 100644 --- a/packages/desktop/src/main/server-manager.ts +++ b/packages/desktop/src/main/server-manager.ts @@ -1,6 +1,7 @@ import { spawn, type ChildProcess } from "node:child_process"; import { getServerEntryPath, + getBunPath, HEALTH_CHECK_INTERVAL, HEALTH_CHECK_TIMEOUT, MAX_RESTART_ATTEMPTS, @@ -18,6 +19,7 @@ export class ServerManager { private isDev: boolean; private restartCount = 0; private stopping = false; + private initialStartup = false; constructor(opts: ServerManagerOptions) { this.port = opts.port; @@ -27,6 +29,7 @@ export class ServerManager { /** Spawn the relay server and wait for it to become healthy. */ async start(): Promise { this.stopping = false; + this.initialStartup = true; // Check if port is available before spawning const portFree = await this.isPortFree(this.port); @@ -47,7 +50,8 @@ export class ServerManager { let earlyExit = false; let earlyExitCode: number | null = null; - this.child = spawn("bun", ["run", entry], { + const bunPath = getBunPath(); + this.child = spawn(bunPath, ["run", entry], { env, stdio: ["ignore", "pipe", "pipe"], }); @@ -65,7 +69,9 @@ export class ServerManager { earlyExit = true; earlyExitCode = code; this.child = null; - if (!this.stopping && this.restartCount < MAX_RESTART_ATTEMPTS) { + // Don't auto-restart during initial startup — let start() reject cleanly + // so the caller can handle the error without a background restart race. + if (!this.stopping && !this.initialStartup && this.restartCount < MAX_RESTART_ATTEMPTS) { this.restartCount++; log.warn(`Restarting server (attempt ${this.restartCount}/${MAX_RESTART_ATTEMPTS})...`); this.start().catch((err) => log.error("Server restart failed:", err)); @@ -73,6 +79,7 @@ export class ServerManager { }); await this.waitForHealthy(() => earlyExit); + this.initialStartup = false; this.restartCount = 0; log.info(`Relay server healthy on port ${this.port}`); } diff --git a/packages/desktop/src/main/tray.ts b/packages/desktop/src/main/tray.ts index 10c90b1f6..8b42de883 100644 --- a/packages/desktop/src/main/tray.ts +++ b/packages/desktop/src/main/tray.ts @@ -6,14 +6,12 @@ import { fileURLToPath } from "node:url"; const __filename = fileURLToPath(import.meta.url); const __dirname = dirname(__filename); import log from "./logger.js"; +import type { ServiceStatus } from "../shared/types.js"; export type ServiceHealth = "healthy" | "degraded" | "error"; -export interface TrayStatus { - server: "starting" | "running" | "error" | "stopped"; - runner: "starting" | "running" | "error" | "stopped"; - redis: "connected" | "disconnected"; -} +/** @deprecated Use ServiceStatus from shared/types.ts */ +export type TrayStatus = ServiceStatus; export class AppTray { private tray: Tray; diff --git a/packages/desktop/src/preload/index.ts b/packages/desktop/src/preload/index.ts index b201de094..936b7c94f 100644 --- a/packages/desktop/src/preload/index.ts +++ b/packages/desktop/src/preload/index.ts @@ -1,12 +1,13 @@ // packages/desktop/src/preload/index.ts -import { contextBridge, ipcRenderer } from "electron"; +import { contextBridge, ipcRenderer, type IpcRendererEvent } from "electron"; +import type { ServiceStatus } from "../shared/types.js"; export interface DesktopAPI { getVersion(): Promise; getPlatform(): Promise; getAutoLaunch(): Promise; setAutoLaunch(enabled: boolean): Promise; - onServiceStatus(callback: (status: any) => void): () => void; + onServiceStatus(callback: (status: ServiceStatus) => void): () => void; } const desktopAPI: DesktopAPI = { @@ -15,7 +16,7 @@ const desktopAPI: DesktopAPI = { getAutoLaunch: () => ipcRenderer.invoke("desktop:getAutoLaunch"), setAutoLaunch: (enabled) => ipcRenderer.invoke("desktop:setAutoLaunch", enabled), onServiceStatus: (callback) => { - const handler = (_event: any, status: any) => callback(status); + const handler = (_event: IpcRendererEvent, status: ServiceStatus) => callback(status); ipcRenderer.on("desktop:serviceStatus", handler); // Return cleanup function return () => ipcRenderer.removeListener("desktop:serviceStatus", handler); diff --git a/packages/desktop/src/shared/types.ts b/packages/desktop/src/shared/types.ts new file mode 100644 index 000000000..047dd8f17 --- /dev/null +++ b/packages/desktop/src/shared/types.ts @@ -0,0 +1,11 @@ +/** + * Shared types between main, preload, and renderer processes. + * Keep this file free of Electron imports so it can be used in any context. + */ + +/** Service status sent from main → renderer via IPC. */ +export interface ServiceStatus { + server: "starting" | "running" | "error" | "stopped"; + runner: "starting" | "running" | "error" | "stopped"; + redis: "connected" | "disconnected"; +} diff --git a/packages/desktop/tests/runner-manager.test.ts b/packages/desktop/tests/runner-manager.test.ts index 4abf23f35..f85be9942 100644 --- a/packages/desktop/tests/runner-manager.test.ts +++ b/packages/desktop/tests/runner-manager.test.ts @@ -25,9 +25,10 @@ mock.module("electron", () => ({ mock.module("../src/main/config.js", () => ({ getRunnerEntryPath: () => "/fake/runner/index.js", getServerEntryPath: () => "/fake/server/index.ts", + getBunPath: () => "bun", MAX_RESTART_ATTEMPTS: 3, HEALTH_CHECK_INTERVAL: 10, - HEALTH_CHECK_TIMEOUT: 1000, + HEALTH_CHECK_TIMEOUT: 500, isDev: true, })); @@ -59,19 +60,41 @@ describe("RunnerManager", () => { const { RunnerManager } = await import("../src/main/runner-manager.js"); const mgr = new RunnerManager({ serverPort: 3001, isDev: true }); - mgr.start(); + // Mock fetch so waitForReady sees a registered runner + const originalFetch = globalThis.fetch; + globalThis.fetch = mock(() => + Promise.resolve(new Response(JSON.stringify({ runners: [{ runnerId: "test" }] }), { + status: 200, + headers: { "Content-Type": "application/json" }, + })) + ) as any; + + await mgr.start(); expect(mockSpawn).toHaveBeenCalled(); expect(mgr.isRunning()).toBe(true); + + globalThis.fetch = originalFetch; }); test("stop() sends SIGTERM to runner", async () => { const { RunnerManager } = await import("../src/main/runner-manager.js"); const mgr = new RunnerManager({ serverPort: 3001, isDev: true }); - mgr.start(); + // Mock fetch so start() completes + const originalFetch = globalThis.fetch; + globalThis.fetch = mock(() => + Promise.resolve(new Response(JSON.stringify({ runners: [{ runnerId: "test" }] }), { + status: 200, + headers: { "Content-Type": "application/json" }, + })) + ) as any; + + await mgr.start(); mgr.stop(); + globalThis.fetch = originalFetch; + expect(mockKill).toHaveBeenCalledWith("SIGTERM"); expect(mgr.isRunning()).toBe(false); }); diff --git a/packages/desktop/tests/server-manager.test.ts b/packages/desktop/tests/server-manager.test.ts index d4ba09374..cb47c5a55 100644 --- a/packages/desktop/tests/server-manager.test.ts +++ b/packages/desktop/tests/server-manager.test.ts @@ -30,6 +30,7 @@ mock.module("../src/main/config.js", () => ({ getServerEntryPath: () => "/fake/server/index.ts", getRunnerEntryPath: () => "/fake/runner/index.js", getUIDistPath: () => "/fake/ui/dist", + getBunPath: () => "bun", HEALTH_CHECK_INTERVAL: 10, HEALTH_CHECK_TIMEOUT: 1000, MAX_RESTART_ATTEMPTS: 3, @@ -60,7 +61,8 @@ describe("ServerManager", () => { test("start() spawns a child process with the correct entry path", async () => { const { ServerManager } = await import("../src/main/server-manager.js"); - const mgr = new ServerManager({ port: 3001, isDev: true }); + const port = 10000 + Math.floor(Math.random() * 50000); + const mgr = new ServerManager({ port, isDev: true }); // Mock fetch for health check const originalFetch = globalThis.fetch; @@ -78,7 +80,8 @@ describe("ServerManager", () => { test("stop() sends SIGTERM to the child process", async () => { const { ServerManager } = await import("../src/main/server-manager.js"); - const mgr = new ServerManager({ port: 3001, isDev: true }); + const port = 10000 + Math.floor(Math.random() * 50000); + const mgr = new ServerManager({ port, isDev: true }); const originalFetch = globalThis.fetch; globalThis.fetch = mock(() => diff --git a/tsconfig.json b/tsconfig.json index 2d4708cf0..3ce9bc1c0 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -6,6 +6,7 @@ { "path": "packages/tools" }, { "path": "packages/server" }, { "path": "packages/ui" }, - { "path": "packages/cli" } + { "path": "packages/cli" }, + { "path": "packages/desktop" } ] } From 666524950c8fd9614a97ee18ad0ab91583051910 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Wed, 1 Apr 2026 12:57:45 -0400 Subject: [PATCH 18/20] fix: remove desktop from root CI pipelines (needs electron devDep) The desktop package requires electron types which aren't available in the standard CI environment. Revert the root tsconfig/test additions and add test/typecheck scripts to the desktop package.json instead so they can be run independently or in a future desktop-specific CI job. --- package.json | 2 +- packages/desktop/package.json | 2 ++ tsconfig.json | 3 +-- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/package.json b/package.json index 864d23646..41b712f7a 100644 --- a/package.json +++ b/package.json @@ -34,7 +34,7 @@ "build:desktop": "bun run build:ui && bun run build:server && bun run build:cli && cd packages/desktop && bun run build", "package:desktop": "bun run build:desktop && cd packages/desktop && bun run package", "dev:runner": "bun packages/cli/src/index.ts runner", - "test": "bun test packages/protocol/src packages/tunnel/src packages/server/src packages/server/tests packages/tools/src packages/desktop/tests && cd packages/cli && bun test src && cd ../ui && bun test src", + "test": "bun test packages/protocol/src packages/tunnel/src packages/server/src packages/server/tests packages/tools/src && cd packages/cli && bun test src && cd ../ui && bun test src", "typecheck": "bun packages/cli/scripts/compile-prompt.ts && tsc --build && bun run --cwd packages/protocol typecheck:tests && bun run --cwd packages/server typecheck:tests", "migrate": "cd packages/server && bun run migrate", "clean": "bun -e \"['protocol','tunnel','tools','server','ui','cli','docs'].forEach(p=>{require('fs').rmSync('packages/'+p+'/dist',{recursive:true,force:true});require('fs').rmSync('packages/'+p+'/tsconfig.tsbuildinfo',{force:true})})\"", diff --git a/packages/desktop/package.json b/packages/desktop/package.json index 7b18909df..dd2e1340a 100644 --- a/packages/desktop/package.json +++ b/packages/desktop/package.json @@ -8,6 +8,8 @@ "dev": "concurrently \"bun run dev:electron\" \"bun run --cwd ../ui dev\" \"bun run --cwd ../server dev\" --kill-others-on-exit", "dev:electron": "electron --inspect . --dev", "build": "tsc --build", + "test": "bun test tests", + "typecheck": "tsc --noEmit", "package": "electron-builder --mac", "start": "electron ." }, diff --git a/tsconfig.json b/tsconfig.json index 3ce9bc1c0..2d4708cf0 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -6,7 +6,6 @@ { "path": "packages/tools" }, { "path": "packages/server" }, { "path": "packages/ui" }, - { "path": "packages/cli" }, - { "path": "packages/desktop" } + { "path": "packages/cli" } ] } From 63c3870388a4c297c948136555e9367b5931e814 Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Wed, 1 Apr 2026 13:17:14 -0400 Subject: [PATCH 19/20] fix: pin @types/node to prevent bun-types resolution drift Adding the desktop workspace caused bun to resolve a separate @types/node@25.3.0 for bun-types, which broke ChildProcess type compatibility in the CLI package. Pin @types/node@22.19.15 via overrides to keep all packages on the same version. --- bun.lock | 65 +++------------------------------------------------- package.json | 3 +++ 2 files changed, 6 insertions(+), 62 deletions(-) diff --git a/bun.lock b/bun.lock index 758caeed0..c183ecd53 100644 --- a/bun.lock +++ b/bun.lock @@ -187,6 +187,9 @@ "@mariozechner/pi-ai@0.63.1": "patches/@mariozechner%2Fpi-ai@0.63.1.patch", "@mariozechner/pi-coding-agent@0.63.1": "patches/@mariozechner%2Fpi-coding-agent@0.63.1.patch", }, + "overrides": { + "@types/node": "22.19.15", + }, "packages": { "7zip-bin": ["7zip-bin@5.2.0", "", {}, "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A=="], @@ -3874,28 +3877,6 @@ "@ts-morph/common/minimatch": ["minimatch@10.2.2", "", { "dependencies": { "brace-expansion": "^5.0.2" } }, "sha512-+G4CpNBxa5MprY+04MbgOw1v7So6n5JY166pFi9KfYwT78fxScCeSNQSNzp6dpPSW2rONOps6Ocam1wFhCgoVw=="], - "@types/cacheable-request/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - - "@types/cors/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - - "@types/fs-extra/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - - "@types/keyv/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - - "@types/pg/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - - "@types/plist/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - - "@types/responselike/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - - "@types/sax/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - - "@types/web-push/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - - "@types/ws/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - - "@types/yauzl/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - "accepts/mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="], "ajv-keywords/ajv": ["ajv@6.14.0", "", { "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" } }, "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw=="], @@ -3924,8 +3905,6 @@ "boxen/string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="], - "bun-types/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - "cacache/glob": ["glob@10.5.0", "", { "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" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="], "cacache/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="], @@ -3978,8 +3957,6 @@ "encoding/iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="], - "engine.io/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - "engine.io/cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="], "engine.io/ws": ["ws@8.18.3", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg=="], @@ -4008,8 +3985,6 @@ "glob/minimatch": ["minimatch@10.2.2", "", { "dependencies": { "brace-expansion": "^5.0.2" } }, "sha512-+G4CpNBxa5MprY+04MbgOw1v7So6n5JY166pFi9KfYwT78fxScCeSNQSNzp6dpPSW2rONOps6Ocam1wFhCgoVw=="], - "happy-dom/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - "hast-util-from-html/parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="], "hast-util-raw/parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="], @@ -4084,8 +4059,6 @@ "prompts/kleur": ["kleur@3.0.3", "", {}, "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w=="], - "protobufjs/@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], - "radix-ui/@radix-ui/react-label": ["@radix-ui/react-label@2.1.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-YT1GqPSL8kJn20djelMX7/cTRp/Y9w5IZHvfxQTVHrOqa2yMl7i/UfMqKRU5V7mEyKTrUVgJXhNQPVCG8PBLoQ=="], "radix-ui/@radix-ui/react-separator": ["@radix-ui/react-separator@1.1.7", "", { "dependencies": { "@radix-ui/react-primitive": "2.1.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-0HEb8R9E8A+jZjvmFCy/J4xhbXy3TV+9XSnGJ3KvTtjlIUy/YQ/p6UYZvi7YbeoeXdyU9+Y3scizK6hkY37baA=="], @@ -4112,8 +4085,6 @@ "shadcn/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="], - "sitemap/@types/node": ["@types/node@17.0.45", "", {}, "sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw=="], - "socket.io-adapter/ws": ["ws@8.18.3", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg=="], "socks/ip-address": ["ip-address@10.1.0", "", {}, "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q=="], @@ -4226,28 +4197,6 @@ "@rollup/plugin-replace/@rollup/pluginutils/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="], - "@types/cacheable-request/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - - "@types/cors/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - - "@types/fs-extra/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - - "@types/keyv/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - - "@types/pg/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - - "@types/plist/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - - "@types/responselike/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - - "@types/sax/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - - "@types/web-push/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - - "@types/ws/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - - "@types/yauzl/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - "accepts/mime-types/mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="], "ajv-keywords/ajv/json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], @@ -4300,8 +4249,6 @@ "boxen/string-width/emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="], - "bun-types/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - "cacache/glob/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], "cacache/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="], @@ -4336,16 +4283,12 @@ "electron-winstaller/fs-extra/universalify": ["universalify@0.1.2", "", {}, "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg=="], - "engine.io/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - "express/accepts/negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="], "filelist/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], "form-data/mime-types/mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="], - "happy-dom/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - "hast-util-from-html/parse5/entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="], "hast-util-raw/parse5/entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="], @@ -4370,8 +4313,6 @@ "ora/string-width/emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="], - "protobufjs/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], - "rimraf/glob/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], "rimraf/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="], diff --git a/package.json b/package.json index 41b712f7a..8fcc0d829 100644 --- a/package.json +++ b/package.json @@ -57,5 +57,8 @@ "patchedDependencies": { "@mariozechner/pi-coding-agent@0.63.1": "patches/@mariozechner%2Fpi-coding-agent@0.63.1.patch", "@mariozechner/pi-ai@0.63.1": "patches/@mariozechner%2Fpi-ai@0.63.1.patch" + }, + "overrides": { + "@types/node": "22.19.15" } } \ No newline at end of file From a474ede5d2accc9ecfcae9f2c33f7357ff51c94f Mon Sep 17 00:00:00 2001 From: Jorge Gonzalez Date: Wed, 1 Apr 2026 13:24:20 -0400 Subject: [PATCH 20/20] fix: remove desktop from root workspaces to avoid @types/node drift MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The desktop package's electron dependency tree caused bun to resolve a separate @types/node@25.3.0 for bun-types, breaking ChildProcess types in the CLI package. Desktop is a standalone Electron app — it doesn't need to be in the monorepo workspace. It manages its own deps via a separate bun install. Also removed the unused @pizzapi/protocol dependency and tsconfig reference (desktop doesn't import from protocol). --- .gitignore | 1 + bun.lock | 461 +-------------------------------- package.json | 7 +- packages/desktop/package.json | 1 - packages/desktop/tsconfig.json | 5 +- 5 files changed, 9 insertions(+), 466 deletions(-) diff --git a/.gitignore b/.gitignore index 9c4286afe..94f95cfdc 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,4 @@ packages/cli/src/config/system-prompt.precompiled.ts 01-landing.png .playwright-cli/ .superpowers/ +packages/desktop/bun.lock diff --git a/bun.lock b/bun.lock index c183ecd53..294503449 100644 --- a/bun.lock +++ b/bun.lock @@ -40,20 +40,6 @@ "typescript": "^5.7.0", }, }, - "packages/desktop": { - "name": "@pizzapi/desktop", - "version": "0.1.0", - "dependencies": { - "@pizzapi/protocol": "workspace:*", - "electron-log": "^5.3.0", - }, - "devDependencies": { - "concurrently": "^9.2.1", - "electron": "^35.0.0", - "electron-builder": "^26.0.0", - "typescript": "^5.7.0", - }, - }, "packages/docs": { "name": "@pizzapi/docs", "version": "0.0.1", @@ -187,12 +173,7 @@ "@mariozechner/pi-ai@0.63.1": "patches/@mariozechner%2Fpi-ai@0.63.1.patch", "@mariozechner/pi-coding-agent@0.63.1": "patches/@mariozechner%2Fpi-coding-agent@0.63.1.patch", }, - "overrides": { - "@types/node": "22.19.15", - }, "packages": { - "7zip-bin": ["7zip-bin@5.2.0", "", {}, "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A=="], - "@ai-sdk/gateway": ["@ai-sdk/gateway@3.0.53", "", { "dependencies": { "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.15", "@vercel/oidc": "3.1.0" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-QT3FEoNARMRlk8JJVR7L98exiK9C8AGfrEJVbRxBT1yIXKs/N19o/+PsjTRVsARgDJNcy9JbJp1FspKucEat0Q=="], "@ai-sdk/provider": ["@ai-sdk/provider@3.0.8", "", { "dependencies": { "json-schema": "^0.4.0" } }, "sha512-oGMAgGoQdBXbZqNG0Ze56CHjDZ1IDYOwGYxYjO5KLSlz5HiNQ9udIXsPZ61VWaHGZ5XW/jyjmr6t2xz2jGVwbQ=="], @@ -549,28 +530,10 @@ "@ctrl/tinycolor": ["@ctrl/tinycolor@4.2.0", "", {}, "sha512-kzyuwOAQnXJNLS9PSyrk0CWk35nWJW/zl/6KvnTBMFK65gm7U1/Z5BqjxeapjZCIhQcM/DsrEmcbRwDyXyXK4A=="], - "@develar/schema-utils": ["@develar/schema-utils@2.6.5", "", { "dependencies": { "ajv": "^6.12.0", "ajv-keywords": "^3.4.1" } }, "sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig=="], - "@dotenvx/dotenvx": ["@dotenvx/dotenvx@1.52.0", "", { "dependencies": { "commander": "^11.1.0", "dotenv": "^17.2.1", "eciesjs": "^0.4.10", "execa": "^5.1.1", "fdir": "^6.2.0", "ignore": "^5.3.0", "object-treeify": "1.1.33", "picomatch": "^4.0.2", "which": "^4.0.0" }, "bin": { "dotenvx": "src/cli/dotenvx.js" } }, "sha512-CaQcc8JvtzQhUSm9877b6V4Tb7HCotkcyud9X2YwdqtQKwgljkMRwU96fVYKnzN3V0Hj74oP7Es+vZ0mS+Aa1w=="], "@ecies/ciphers": ["@ecies/ciphers@0.2.5", "", { "peerDependencies": { "@noble/ciphers": "^1.0.0" } }, "sha512-GalEZH4JgOMHYYcYmVqnFirFsjZHeoGMDt9IxEnM9F7GRUUyUksJ7Ou53L83WHJq3RWKD3AcBpo0iQh0oMpf8A=="], - "@electron/asar": ["@electron/asar@3.4.1", "", { "dependencies": { "commander": "^5.0.0", "glob": "^7.1.6", "minimatch": "^3.0.4" }, "bin": { "asar": "bin/asar.js" } }, "sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA=="], - - "@electron/fuses": ["@electron/fuses@1.8.0", "", { "dependencies": { "chalk": "^4.1.1", "fs-extra": "^9.0.1", "minimist": "^1.2.5" }, "bin": { "electron-fuses": "dist/bin.js" } }, "sha512-zx0EIq78WlY/lBb1uXlziZmDZI4ubcCXIMJ4uGjXzZW0nS19TjSPeXPAjzzTmKQlJUZm0SbmZhPKP7tuQ1SsEw=="], - - "@electron/get": ["@electron/get@2.0.3", "", { "dependencies": { "debug": "^4.1.1", "env-paths": "^2.2.0", "fs-extra": "^8.1.0", "got": "^11.8.5", "progress": "^2.0.3", "semver": "^6.2.0", "sumchecker": "^3.0.1" }, "optionalDependencies": { "global-agent": "^3.0.0" } }, "sha512-Qkzpg2s9GnVV2I2BjRksUi43U5e6+zaQMcjoJy0C+C5oxaKl+fmckGDQFtRpZpZV0NQekuZZ+tGz7EA9TVnQtQ=="], - - "@electron/notarize": ["@electron/notarize@2.5.0", "", { "dependencies": { "debug": "^4.1.1", "fs-extra": "^9.0.1", "promise-retry": "^2.0.1" } }, "sha512-jNT8nwH1f9X5GEITXaQ8IF/KdskvIkOFfB2CvwumsveVidzpSc+mvhhTMdAGSYF3O+Nq49lJ7y+ssODRXu06+A=="], - - "@electron/osx-sign": ["@electron/osx-sign@1.3.3", "", { "dependencies": { "compare-version": "^0.1.2", "debug": "^4.3.4", "fs-extra": "^10.0.0", "isbinaryfile": "^4.0.8", "minimist": "^1.2.6", "plist": "^3.0.5" }, "bin": { "electron-osx-flat": "bin/electron-osx-flat.js", "electron-osx-sign": "bin/electron-osx-sign.js" } }, "sha512-KZ8mhXvWv2rIEgMbWZ4y33bDHyUKMXnx4M0sTyPNK/vcB81ImdeY9Ggdqy0SWbMDgmbqyQ+phgejh6V3R2QuSg=="], - - "@electron/rebuild": ["@electron/rebuild@4.0.3", "", { "dependencies": { "@malept/cross-spawn-promise": "^2.0.0", "debug": "^4.1.1", "detect-libc": "^2.0.1", "got": "^11.7.0", "graceful-fs": "^4.2.11", "node-abi": "^4.2.0", "node-api-version": "^0.2.1", "node-gyp": "^11.2.0", "ora": "^5.1.0", "read-binary-file-arch": "^1.0.6", "semver": "^7.3.5", "tar": "^7.5.6", "yargs": "^17.0.1" }, "bin": { "electron-rebuild": "lib/cli.js" } }, "sha512-u9vpTHRMkOYCs/1FLiSVAFZ7FbjsXK+bQuzviJZa+lG7BHZl1nz52/IcGvwa3sk80/fc3llutBkbCq10Vh8WQA=="], - - "@electron/universal": ["@electron/universal@2.0.3", "", { "dependencies": { "@electron/asar": "^3.3.1", "@malept/cross-spawn-promise": "^2.0.0", "debug": "^4.3.1", "dir-compare": "^4.2.0", "fs-extra": "^11.1.1", "minimatch": "^9.0.3", "plist": "^3.1.0" } }, "sha512-Wn9sPYIVFRFl5HmwMJkARCCf7rqK/EurkfQ/rJZ14mHP3iYTjZSIOSVonEAnhWeAXwtw7zOekGRlc6yTtZ0t+g=="], - - "@electron/windows-sign": ["@electron/windows-sign@1.2.2", "", { "dependencies": { "cross-dirname": "^0.1.0", "debug": "^4.3.4", "fs-extra": "^11.1.1", "minimist": "^1.2.8", "postject": "^1.0.0-alpha.6" }, "bin": { "electron-windows-sign": "bin/electron-windows-sign.js" } }, "sha512-dfZeox66AvdPtb2lD8OsIIQh12Tp0GNCRUDfBHIKGpbmopZto2/A8nSpYYLoedPIHpqkeblZ/k8OV0Gy7PYuyQ=="], - "@emnapi/runtime": ["@emnapi/runtime@1.8.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-mehfKSMWjjNol8659Z8KxEMrdSJDDot5SXMq00dM8BN4o+CLNXQ0xH2V7EchNHV4RmbZLmmPdEaXZc5H2FXmDg=="], "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.3", "", { "os": "aix", "cpu": "ppc64" }, "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg=="], @@ -725,10 +688,6 @@ "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="], - "@malept/cross-spawn-promise": ["@malept/cross-spawn-promise@2.0.0", "", { "dependencies": { "cross-spawn": "^7.0.1" } }, "sha512-1DpKU0Z5ThltBwjNySMC14g0CkbyhCaz9FkhxqNsZI6uAPJXFS8cMXlBKo26FJ8ZuW6S9GCMcR9IO5k2X5/9Fg=="], - - "@malept/flatpak-bundler": ["@malept/flatpak-bundler@0.4.0", "", { "dependencies": { "debug": "^4.1.1", "fs-extra": "^9.0.0", "lodash": "^4.17.15", "tmp-promise": "^3.0.2" } }, "sha512-9QOtNffcOF/c1seMCDnjckb3R9WHcG34tky+FHpNKKCW0wc/scYLwMtO+ptyGUfMW0/b/n4qRiALlaFHc9Oj7Q=="], - "@mariozechner/clipboard": ["@mariozechner/clipboard@0.3.2", "", { "optionalDependencies": { "@mariozechner/clipboard-darwin-arm64": "0.3.2", "@mariozechner/clipboard-darwin-universal": "0.3.2", "@mariozechner/clipboard-darwin-x64": "0.3.2", "@mariozechner/clipboard-linux-arm64-gnu": "0.3.2", "@mariozechner/clipboard-linux-arm64-musl": "0.3.2", "@mariozechner/clipboard-linux-riscv64-gnu": "0.3.2", "@mariozechner/clipboard-linux-x64-gnu": "0.3.2", "@mariozechner/clipboard-linux-x64-musl": "0.3.2", "@mariozechner/clipboard-win32-arm64-msvc": "0.3.2", "@mariozechner/clipboard-win32-x64-msvc": "0.3.2" } }, "sha512-IHQpksNjo7EAtGuHFU+tbWDp5LarH3HU/8WiB9O70ZEoBPHOg0/6afwSLK0QyNMMmx4Bpi/zl6+DcBXe95nWYA=="], "@mariozechner/clipboard-darwin-arm64": ["@mariozechner/clipboard-darwin-arm64@0.3.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-uBf6K7Je1ihsgvmWxA8UCGCeI+nbRVRXoarZdLjl6slz94Zs1tNKFZqx7aCI5O1i3e0B6ja82zZ06BWrl0MCVw=="], @@ -785,10 +744,6 @@ "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="], - "@npmcli/agent": ["@npmcli/agent@3.0.0", "", { "dependencies": { "agent-base": "^7.1.0", "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.1", "lru-cache": "^10.0.1", "socks-proxy-agent": "^8.0.3" } }, "sha512-S79NdEgDQd/NGCay6TCoVzXSj74skRZIKJcpJjC5lOq34SZzyI6MqtiiWoiVWoVrTcGjNeC4ipbh1VIHlpfF5Q=="], - - "@npmcli/fs": ["@npmcli/fs@4.0.0", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-/xGlezI6xfGO9NwuJlnwz/K14qD1kCSAGtacBHnGzeAIuJGazcp45KP5NuyARXoKb7cwulAGWVsbeSxdG/cb0Q=="], - "@open-draft/deferred-promise": ["@open-draft/deferred-promise@2.2.0", "", {}, "sha512-CecwLWx3rhxVQF6V4bAgPS5t+So2sTbPgAzafKkVizyi7tlwpcFpdFqq+wqF2OwNBmqFuu6tOyouTuxgpMfzmA=="], "@open-draft/logger": ["@open-draft/logger@0.3.0", "", { "dependencies": { "is-node-process": "^1.2.0", "outvariant": "^1.4.0" } }, "sha512-X2g45fzhxH238HKO4xbSr7+wBS8Fvw6ixhTDuvLd5mqh6bJJCFAPwU9mPDxbcrRtfxv4u5IHCEH77BmxvXmmxQ=="], @@ -815,8 +770,6 @@ "@pizzapi/cli": ["@pizzapi/cli@workspace:packages/cli"], - "@pizzapi/desktop": ["@pizzapi/desktop@workspace:packages/desktop"], - "@pizzapi/docs": ["@pizzapi/docs@workspace:packages/docs"], "@pizzapi/protocol": ["@pizzapi/protocol@workspace:packages/protocol"], @@ -1075,8 +1028,6 @@ "@sinclair/typebox": ["@sinclair/typebox@0.34.48", "", {}, "sha512-kKJTNuK3AQOrgjjotVxMrCn1sUJwM76wMszfq1kdU4uYVJjvEWuFQ6HgvLt4Xz3fSmZlTOxJ/Ie13KnIcWQXFA=="], - "@sindresorhus/is": ["@sindresorhus/is@4.6.0", "", {}, "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw=="], - "@sindresorhus/merge-streams": ["@sindresorhus/merge-streams@4.0.0", "", {}, "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ=="], "@smithy/abort-controller": ["@smithy/abort-controller@4.2.8", "", { "dependencies": { "@smithy/types": "^4.12.0", "tslib": "^2.6.2" } }, "sha512-peuVfkYHAmS5ybKxWcfraK7WBBP0J+rkfUcbHJJKQ4ir3UAUNQI+Y4Vt/PqSzGqgloJ5O1dk7+WzNL8wcCSXbw=="], @@ -1225,8 +1176,6 @@ "@swc/types": ["@swc/types@0.1.25", "", { "dependencies": { "@swc/counter": "^0.1.3" } }, "sha512-iAoY/qRhNH8a/hBvm3zKj9qQ4oc2+3w1unPJa2XvTK3XjeLXtzcCingVPw/9e5mn1+0yPqxcBGp9Jf0pkfMb1g=="], - "@szmarczak/http-timer": ["@szmarczak/http-timer@4.0.6", "", { "dependencies": { "defer-to-connect": "^2.0.0" } }, "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w=="], - "@tailwindcss/node": ["@tailwindcss/node@4.2.0", "", { "dependencies": { "@jridgewell/remapping": "^2.3.5", "enhanced-resolve": "^5.19.0", "jiti": "^2.6.1", "lightningcss": "1.31.1", "magic-string": "^0.30.21", "source-map-js": "^1.2.1", "tailwindcss": "4.2.0" } }, "sha512-Yv+fn/o2OmL5fh/Ir62VXItdShnUxfpkMA4Y7jdeC8O81WPB8Kf6TT6GSHvnqgSwDzlB5iT7kDpeXxLsUS0T6Q=="], "@tailwindcss/oxide": ["@tailwindcss/oxide@4.2.0", "", { "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.2.0", "@tailwindcss/oxide-darwin-arm64": "4.2.0", "@tailwindcss/oxide-darwin-x64": "4.2.0", "@tailwindcss/oxide-freebsd-x64": "4.2.0", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.2.0", "@tailwindcss/oxide-linux-arm64-gnu": "4.2.0", "@tailwindcss/oxide-linux-arm64-musl": "4.2.0", "@tailwindcss/oxide-linux-x64-gnu": "4.2.0", "@tailwindcss/oxide-linux-x64-musl": "4.2.0", "@tailwindcss/oxide-wasm32-wasi": "4.2.0", "@tailwindcss/oxide-win32-arm64-msvc": "4.2.0", "@tailwindcss/oxide-win32-x64-msvc": "4.2.0" } }, "sha512-AZqQzADaj742oqn2xjl5JbIOzZB/DGCYF/7bpvhA8KvjUj9HJkag6bBuwZvH1ps6dfgxNHyuJVlzSr2VpMgdTQ=="], @@ -1285,8 +1234,6 @@ "@types/bun": ["@types/bun@1.3.9", "", { "dependencies": { "bun-types": "1.3.9" } }, "sha512-KQ571yULOdWJiMH+RIWIOZ7B2RXQGpL1YQrBtLIV3FqDcCu6FsbFUBwhdKUlCKUpS3PJDsHlJ1QKlpxoVR+xtw=="], - "@types/cacheable-request": ["@types/cacheable-request@6.0.3", "", { "dependencies": { "@types/http-cache-semantics": "*", "@types/keyv": "^3.1.4", "@types/node": "*", "@types/responselike": "^1.0.0" } }, "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw=="], - "@types/cors": ["@types/cors@2.8.19", "", { "dependencies": { "@types/node": "*" } }, "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg=="], "@types/d3": ["@types/d3@7.4.3", "", { "dependencies": { "@types/d3-array": "*", "@types/d3-axis": "*", "@types/d3-brush": "*", "@types/d3-chord": "*", "@types/d3-color": "*", "@types/d3-contour": "*", "@types/d3-delaunay": "*", "@types/d3-dispatch": "*", "@types/d3-drag": "*", "@types/d3-dsv": "*", "@types/d3-ease": "*", "@types/d3-fetch": "*", "@types/d3-force": "*", "@types/d3-format": "*", "@types/d3-geo": "*", "@types/d3-hierarchy": "*", "@types/d3-interpolate": "*", "@types/d3-path": "*", "@types/d3-polygon": "*", "@types/d3-quadtree": "*", "@types/d3-random": "*", "@types/d3-scale": "*", "@types/d3-scale-chromatic": "*", "@types/d3-selection": "*", "@types/d3-shape": "*", "@types/d3-time": "*", "@types/d3-time-format": "*", "@types/d3-timer": "*", "@types/d3-transition": "*", "@types/d3-zoom": "*" } }, "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww=="], @@ -1357,20 +1304,14 @@ "@types/estree-jsx": ["@types/estree-jsx@1.0.5", "", { "dependencies": { "@types/estree": "*" } }, "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg=="], - "@types/fs-extra": ["@types/fs-extra@9.0.13", "", { "dependencies": { "@types/node": "*" } }, "sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA=="], - "@types/geojson": ["@types/geojson@7946.0.16", "", {}, "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg=="], "@types/hast": ["@types/hast@3.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ=="], - "@types/http-cache-semantics": ["@types/http-cache-semantics@4.2.0", "", {}, "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q=="], - "@types/js-yaml": ["@types/js-yaml@4.0.9", "", {}, "sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg=="], "@types/katex": ["@types/katex@0.16.8", "", {}, "sha512-trgaNyfU+Xh2Tc+ABIb44a5AYUpicB3uwirOioeOkNPPbmgRNtcWyDeeFRzjPZENO9Vq8gvVqfhaaXWLlevVwg=="], - "@types/keyv": ["@types/keyv@3.1.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg=="], - "@types/lodash": ["@types/lodash@4.17.24", "", {}, "sha512-gIW7lQLZbue7lRSWEFql49QJJWThrTFFeIMJdp3eH4tKoxm1OvEPg02rm4wCCSHS0cL3/Fizimb35b7k8atwsQ=="], "@types/lodash-es": ["@types/lodash-es@4.17.12", "", { "dependencies": { "@types/lodash": "*" } }, "sha512-0NgftHUcV4v34VhXm8QBSftKVXtbkBG3ViCjs6+eJ5a6y6Mi/jiFGPc1sC7QK+9BFhWrURE3EOggmWaSxL9OzQ=="], @@ -1389,8 +1330,6 @@ "@types/pg": ["@types/pg@8.16.0", "", { "dependencies": { "@types/node": "*", "pg-protocol": "*", "pg-types": "^2.2.0" } }, "sha512-RmhMd/wD+CF8Dfo+cVIy3RR5cl8CyfXQ0tGgW6XBL8L4LM/UTEbNXYRbLwU6w+CgrKBNbrQWt4FUtTfaU5jSYQ=="], - "@types/plist": ["@types/plist@3.0.5", "", { "dependencies": { "@types/node": "*", "xmlbuilder": ">=11.0.1" } }, "sha512-E6OCaRmAe4WDmWNsL/9RMqdkkzDCY1etutkflWk4c+AcjDU07Pcz1fQwTX0TQz+Pxqn9i4L1TU3UFpjnrcDgxA=="], - "@types/react": ["@types/react@19.2.14", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w=="], "@types/react-dom": ["@types/react-dom@19.2.3", "", { "peerDependencies": { "@types/react": "^19.2.0" } }, "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ=="], @@ -1399,8 +1338,6 @@ "@types/resolve": ["@types/resolve@1.20.2", "", {}, "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q=="], - "@types/responselike": ["@types/responselike@1.0.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw=="], - "@types/retry": ["@types/retry@0.12.0", "", {}, "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA=="], "@types/sax": ["@types/sax@1.2.7", "", { "dependencies": { "@types/node": "*" } }, "sha512-rO73L89PJxeYM3s3pPPjiPgVVcymqU490g0YO5n5By0k2Erzj6tay/4lr1CHAAU4JyOWd1rpQ8bCf6cZfHU96A=="], @@ -1415,8 +1352,6 @@ "@types/validate-npm-package-name": ["@types/validate-npm-package-name@4.0.2", "", {}, "sha512-lrpDziQipxCEeK5kWxvljWYhUvOiB2A9izZd9B2AFarYAkqZshb4lPbRs7zKEic6eGtH8V/2qJW+dPp9OtF6bw=="], - "@types/verror": ["@types/verror@1.10.11", "", {}, "sha512-RlDm9K7+o5stv0Co8i8ZRGxDbrTxhJtgjqjFyVh/tXQyl/rYtTKlnTvZ88oSTeYREWurwx20Js4kTuKCsFkUtg=="], - "@types/web-push": ["@types/web-push@3.6.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-GnJmSr40H3RAnj0s34FNTcJi1hmWFV5KXugE0mYWnYhgTAHLJ/dJKAwDmvPJYMke0RplY2XE9LnM4hqSqKIjhQ=="], "@types/whatwg-mimetype": ["@types/whatwg-mimetype@3.0.2", "", {}, "sha512-c2AKvDT8ToxLIOUlN51gTiHXflsfIFisS4pO7pDPoKouJCESkhZnEy623gwP9laCy5lnLDAw1vAzu2vM2YLOrA=="], @@ -1433,8 +1368,6 @@ "@vitejs/plugin-react-swc": ["@vitejs/plugin-react-swc@4.3.0", "", { "dependencies": { "@rolldown/pluginutils": "1.0.0-rc.7", "@swc/core": "^1.15.11" }, "peerDependencies": { "vite": "^4 || ^5 || ^6 || ^7 || ^8" } }, "sha512-mOkXCII839dHyAt/gpoSlm28JIVDwhZ6tnG6wJxUy2bmOx7UaPjvOyIDf3SFv5s7Eo7HVaq6kRcu6YMEzt5Z7w=="], - "@xmldom/xmldom": ["@xmldom/xmldom@0.8.12", "", {}, "sha512-9k/gHF6n/pAi/9tqr3m3aqkuiNosYTurLLUtc7xQ9sxB/wm7WPygCv8GYa6mS0fLJEHhqMC1ATYhz++U/lRHqg=="], - "@xterm/addon-fit": ["@xterm/addon-fit@0.11.0", "", {}, "sha512-jYcgT6xtVYhnhgxh3QgYDnnNMYTcf8ElbxxFzX0IZo+vabQqSPAjC3c1wJrKB5E19VwQei89QCiZZP86DCPF7g=="], "@xterm/addon-web-links": ["@xterm/addon-web-links@0.12.0", "", {}, "sha512-4Smom3RPyVp7ZMYOYDoC/9eGJJJqYhnPLGGqJ6wOBfB8VxPViJNSKdgRYb8NpaM6YSelEKbA2SStD7lGyqaobw=="], @@ -1453,8 +1386,6 @@ "@zenyr/bun-pty-win32-x64": ["@zenyr/bun-pty-win32-x64@0.4.4", "", { "os": "win32", "cpu": "x64" }, "sha512-esZqEjPHPWRfAd/IZNaC4mptJ2HFdPXJQPUZVIdrwxEumL7NRoQZXVrlO7MRSO2Jrjqgna4IuQIvOKvCwJNMrg=="], - "abbrev": ["abbrev@3.0.1", "", {}, "sha512-AO2ac6pjRB3SJmGJo+v5/aK6Omggp6fsLrs6wN9bd35ulu4cCwaAU9+7ZhXjeqHVkaHThLuzH0nZr0YpCDhygg=="], - "accepts": ["accepts@1.3.8", "", { "dependencies": { "mime-types": "~2.1.34", "negotiator": "0.6.3" } }, "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw=="], "acorn": ["acorn@8.16.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw=="], @@ -1469,8 +1400,6 @@ "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="], - "ajv-keywords": ["ajv-keywords@3.5.2", "", { "peerDependencies": { "ajv": "^6.9.1" } }, "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ=="], - "anser": ["anser@2.3.5", "", {}, "sha512-vcZjxvvVoxTeR5XBNJB38oTu/7eDCZlwdz32N1eNgpyPF7j/Z7Idf+CUwQOkKKpJ7RJyjxgLHCM7vdIK0iCNMQ=="], "ansi-align": ["ansi-align@3.0.1", "", { "dependencies": { "string-width": "^4.1.0" } }, "sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w=="], @@ -1487,10 +1416,6 @@ "anymatch": ["anymatch@3.1.3", "", { "dependencies": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" } }, "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw=="], - "app-builder-bin": ["app-builder-bin@5.0.0-alpha.12", "", {}, "sha512-j87o0j6LqPL3QRr8yid6c+Tt5gC7xNfYo6uQIQkorAC6MpeayVMZrEDzKmJJ/Hlv7EnOQpaRm53k6ktDYZyB6w=="], - - "app-builder-lib": ["app-builder-lib@26.8.1", "", { "dependencies": { "@develar/schema-utils": "~2.6.5", "@electron/asar": "3.4.1", "@electron/fuses": "^1.8.0", "@electron/get": "^3.0.0", "@electron/notarize": "2.5.0", "@electron/osx-sign": "1.3.3", "@electron/rebuild": "^4.0.3", "@electron/universal": "2.0.3", "@malept/flatpak-bundler": "^0.4.0", "@types/fs-extra": "9.0.13", "async-exit-hook": "^2.0.1", "builder-util": "26.8.1", "builder-util-runtime": "9.5.1", "chromium-pickle-js": "^0.2.0", "ci-info": "4.3.1", "debug": "^4.3.4", "dotenv": "^16.4.5", "dotenv-expand": "^11.0.6", "ejs": "^3.1.8", "electron-publish": "26.8.1", "fs-extra": "^10.1.0", "hosted-git-info": "^4.1.0", "isbinaryfile": "^5.0.0", "jiti": "^2.4.2", "js-yaml": "^4.1.0", "json5": "^2.2.3", "lazy-val": "^1.0.5", "minimatch": "^10.0.3", "plist": "3.1.0", "proper-lockfile": "^4.1.2", "resedit": "^1.7.0", "semver": "~7.7.3", "tar": "^7.5.7", "temp-file": "^3.4.0", "tiny-async-pool": "1.3.0", "which": "^5.0.0" }, "peerDependencies": { "dmg-builder": "26.8.1", "electron-builder-squirrel-windows": "26.8.1" } }, "sha512-p0Im/Dx5C4tmz8QEE1Yn4MkuPC8PrnlRneMhWJj7BBXQfNTJUshM/bp3lusdEsDbvvfJZpXWnYesgSLvwtM2Zw=="], - "arg": ["arg@5.0.2", "", {}, "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg=="], "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="], @@ -1507,12 +1432,8 @@ "asn1.js": ["asn1.js@5.4.1", "", { "dependencies": { "bn.js": "^4.0.0", "inherits": "^2.0.1", "minimalistic-assert": "^1.0.0", "safer-buffer": "^2.1.0" } }, "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA=="], - "assert-plus": ["assert-plus@1.0.0", "", {}, "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw=="], - "ast-types": ["ast-types@0.16.1", "", { "dependencies": { "tslib": "^2.0.1" } }, "sha512-6t10qk83GOG8p0vKmaCr8eiilZwO171AvbROMtvvNiwrTly62t+7XkA8RdIIVbpMhCASAsxgAzdRSwh6nw/5Dg=="], - "astral-regex": ["astral-regex@2.0.0", "", {}, "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ=="], - "astring": ["astring@1.9.0", "", { "bin": { "astring": "bin/astring" } }, "sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg=="], "astro": ["astro@5.17.3", "", { "dependencies": { "@astrojs/compiler": "^2.13.0", "@astrojs/internal-helpers": "0.7.5", "@astrojs/markdown-remark": "6.3.10", "@astrojs/telemetry": "3.3.0", "@capsizecss/unpack": "^4.0.0", "@oslojs/encoding": "^1.1.0", "@rollup/pluginutils": "^5.3.0", "acorn": "^8.15.0", "aria-query": "^5.3.2", "axobject-query": "^4.1.0", "boxen": "8.0.1", "ci-info": "^4.3.1", "clsx": "^2.1.1", "common-ancestor-path": "^1.0.1", "cookie": "^1.1.1", "cssesc": "^3.0.0", "debug": "^4.4.3", "deterministic-object-hash": "^2.0.2", "devalue": "^5.6.2", "diff": "^8.0.3", "dlv": "^1.1.3", "dset": "^3.1.4", "es-module-lexer": "^1.7.0", "esbuild": "^0.27.3", "estree-walker": "^3.0.3", "flattie": "^1.1.1", "fontace": "~0.4.0", "github-slugger": "^2.0.0", "html-escaper": "3.0.3", "http-cache-semantics": "^4.2.0", "import-meta-resolve": "^4.2.0", "js-yaml": "^4.1.1", "magic-string": "^0.30.21", "magicast": "^0.5.1", "mrmime": "^2.0.1", "neotraverse": "^0.6.18", "p-limit": "^6.2.0", "p-queue": "^8.1.1", "package-manager-detector": "^1.6.0", "piccolore": "^0.1.3", "picomatch": "^4.0.3", "prompts": "^2.4.2", "rehype": "^13.0.2", "semver": "^7.7.3", "shiki": "^3.21.0", "smol-toml": "^1.6.0", "svgo": "^4.0.0", "tinyexec": "^1.0.2", "tinyglobby": "^0.2.15", "tsconfck": "^3.1.6", "ultrahtml": "^1.6.0", "unifont": "~0.7.3", "unist-util-visit": "^5.0.0", "unstorage": "^1.17.4", "vfile": "^6.0.3", "vite": "^6.4.1", "vitefu": "^1.1.1", "xxhash-wasm": "^1.1.0", "yargs-parser": "^21.1.1", "yocto-spinner": "^0.2.3", "zod": "^3.25.76", "zod-to-json-schema": "^3.25.1", "zod-to-ts": "^1.2.0" }, "optionalDependencies": { "sharp": "^0.34.0" }, "bin": { "astro": "astro.js" } }, "sha512-69dcfPe8LsHzklwj+hl+vunWUbpMB6pmg35mACjetxbJeUNNys90JaBM8ZiwsPK689SAj/4Zqb1ayaANls9/MA=="], @@ -1521,12 +1442,8 @@ "async": ["async@3.2.6", "", {}, "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA=="], - "async-exit-hook": ["async-exit-hook@2.0.1", "", {}, "sha512-NW2cX8m1Q7KPA7a5M2ULQeZ2wR5qI5PAbw5L0UOMxdioVk9PMZ0h1TmyZEkPYrCvYjDlFICusOu1dlEKAAeXBw=="], - "async-function": ["async-function@1.0.0", "", {}, "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA=="], - "asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="], - "at-least-node": ["at-least-node@1.0.0", "", {}, "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg=="], "available-typed-arrays": ["available-typed-arrays@1.0.7", "", { "dependencies": { "possible-typed-array-names": "^1.0.0" } }, "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ=="], @@ -1575,8 +1492,6 @@ "boolbase": ["boolbase@1.0.0", "", {}, "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww=="], - "boolean": ["boolean@3.2.0", "", {}, "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw=="], - "bowser": ["bowser@2.14.1", "", {}, "sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg=="], "boxen": ["boxen@8.0.1", "", { "dependencies": { "ansi-align": "^3.0.1", "camelcase": "^8.0.0", "chalk": "^5.3.0", "cli-boxes": "^3.0.0", "string-width": "^7.2.0", "type-fest": "^4.21.0", "widest-line": "^5.0.0", "wrap-ansi": "^9.0.0" } }, "sha512-F3PH5k5juxom4xktynS7MoFY+NUWH5LC4CnH11YB8NPew+HLpmBLCybSAEyb2F+4pRXhuhWqFesoQd6DAyc2hw=="], @@ -1595,10 +1510,6 @@ "buffer-from": ["buffer-from@1.1.2", "", {}, "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="], - "builder-util": ["builder-util@26.8.1", "", { "dependencies": { "7zip-bin": "~5.2.0", "@types/debug": "^4.1.6", "app-builder-bin": "5.0.0-alpha.12", "builder-util-runtime": "9.5.1", "chalk": "^4.1.2", "cross-spawn": "^7.0.6", "debug": "^4.3.4", "fs-extra": "^10.1.0", "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.0", "js-yaml": "^4.1.0", "sanitize-filename": "^1.6.3", "source-map-support": "^0.5.19", "stat-mode": "^1.0.0", "temp-file": "^3.4.0", "tiny-async-pool": "1.3.0" } }, "sha512-pm1lTYbGyc90DHgCDO7eo8Rl4EqKLciayNbZqGziqnH9jrlKe8ZANGdityLZU+pJh16dfzjAx2xQq9McuIPEtw=="], - - "builder-util-runtime": ["builder-util-runtime@9.5.1", "", { "dependencies": { "debug": "^4.3.4", "sax": "^1.2.4" } }, "sha512-qt41tMfgHTllhResqM5DcnHyDIWNgzHvuY2jDcYP9iaGpkWxTUzV6GQjDeLnlR1/DtdlcsWQbA7sByMpmJFTLQ=="], - "bun-types": ["bun-types@1.3.9", "", { "dependencies": { "@types/node": "*" } }, "sha512-+UBWWOakIP4Tswh0Bt0QD0alpTY8cb5hvgiYeWCMet9YukHbzuruIEeXC2D7nMJPB12kbh8C7XJykSexEqGKJg=="], "bundle-name": ["bundle-name@4.1.0", "", { "dependencies": { "run-applescript": "^7.0.0" } }, "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q=="], @@ -1609,12 +1520,6 @@ "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="], - "cacache": ["cacache@19.0.1", "", { "dependencies": { "@npmcli/fs": "^4.0.0", "fs-minipass": "^3.0.0", "glob": "^10.2.2", "lru-cache": "^10.0.1", "minipass": "^7.0.3", "minipass-collect": "^2.0.1", "minipass-flush": "^1.0.5", "minipass-pipeline": "^1.2.4", "p-map": "^7.0.2", "ssri": "^12.0.0", "tar": "^7.4.3", "unique-filename": "^4.0.0" } }, "sha512-hdsUxulXCi5STId78vRVYEtDAjq99ICAUktLTeTYsLoTE6Z8dS0c8pWNCxwdrk9YfJeobDZc2Y186hD/5ZQgFQ=="], - - "cacheable-lookup": ["cacheable-lookup@5.0.4", "", {}, "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA=="], - - "cacheable-request": ["cacheable-request@7.0.4", "", { "dependencies": { "clone-response": "^1.0.2", "get-stream": "^5.1.0", "http-cache-semantics": "^4.0.0", "keyv": "^4.0.0", "lowercase-keys": "^2.0.0", "normalize-url": "^6.0.1", "responselike": "^2.0.0" } }, "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg=="], - "call-bind": ["call-bind@1.0.8", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.0", "es-define-property": "^1.0.0", "get-intrinsic": "^1.2.4", "set-function-length": "^1.2.2" } }, "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww=="], "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="], @@ -1647,8 +1552,6 @@ "chownr": ["chownr@3.0.0", "", {}, "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g=="], - "chromium-pickle-js": ["chromium-pickle-js@0.2.0", "", {}, "sha512-1R5Fho+jBq0DDydt+/vHWj5KJNJCKdARKOCwZUen84I5BreWoLqRLANH1U87eJy1tiASPtMnGqJJq0ZsLoRPOw=="], - "ci-info": ["ci-info@4.4.0", "", {}, "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg=="], "citty": ["citty@0.1.6", "", { "dependencies": { "consola": "^3.2.3" } }, "sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ=="], @@ -1663,16 +1566,10 @@ "cli-spinners": ["cli-spinners@2.9.2", "", {}, "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg=="], - "cli-truncate": ["cli-truncate@2.1.0", "", { "dependencies": { "slice-ansi": "^3.0.0", "string-width": "^4.2.0" } }, "sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg=="], - "cli-width": ["cli-width@4.1.0", "", {}, "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ=="], "cliui": ["cliui@8.0.1", "", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" } }, "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ=="], - "clone": ["clone@1.0.4", "", {}, "sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg=="], - - "clone-response": ["clone-response@1.0.3", "", { "dependencies": { "mimic-response": "^1.0.0" } }, "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA=="], - "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="], "cluster-key-slot": ["cluster-key-slot@1.1.2", "", {}, "sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA=="], @@ -1693,8 +1590,6 @@ "colorette": ["colorette@2.0.20", "", {}, "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w=="], - "combined-stream": ["combined-stream@1.0.8", "", { "dependencies": { "delayed-stream": "~1.0.0" } }, "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg=="], - "comma-separated-tokens": ["comma-separated-tokens@2.0.3", "", {}, "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg=="], "commander": ["commander@12.1.0", "", {}, "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA=="], @@ -1705,10 +1600,6 @@ "commondir": ["commondir@1.0.1", "", {}, "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg=="], - "compare-version": ["compare-version@0.1.2", "", {}, "sha512-pJDh5/4wrEnXX/VWRZvruAGHkzKdr46z11OlTPN+VrATlWWhSKewNCJ1futCO5C7eJB3nPMFZA1LeYtcFboZ2A=="], - - "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="], - "concurrently": ["concurrently@9.2.1", "", { "dependencies": { "chalk": "4.1.2", "rxjs": "7.8.2", "shell-quote": "1.8.3", "supports-color": "8.1.1", "tree-kill": "1.2.2", "yargs": "17.7.2" }, "bin": { "conc": "dist/bin/concurrently.js", "concurrently": "dist/bin/concurrently.js" } }, "sha512-fsfrO0MxV64Znoy8/l1vVIjjHa29SZyyqPgQBwhiDcaW8wJc2W3XWVOGx4M3oJBnv/zdUZIIp1gDeS98GzP8Ng=="], "confbox": ["confbox@0.2.4", "", {}, "sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ=="], @@ -1729,18 +1620,12 @@ "core-js-compat": ["core-js-compat@3.48.0", "", { "dependencies": { "browserslist": "^4.28.1" } }, "sha512-OM4cAF3D6VtH/WkLtWvyNC56EZVXsZdU3iqaMG2B4WvYrlqU831pc4UtG5yp0sE9z8Y02wVN7PjW5Zf9Gt0f1Q=="], - "core-util-is": ["core-util-is@1.0.2", "", {}, "sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ=="], - "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="], "cose-base": ["cose-base@1.0.3", "", { "dependencies": { "layout-base": "^1.0.0" } }, "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg=="], "cosmiconfig": ["cosmiconfig@9.0.0", "", { "dependencies": { "env-paths": "^2.2.1", "import-fresh": "^3.3.0", "js-yaml": "^4.1.0", "parse-json": "^5.2.0" }, "peerDependencies": { "typescript": ">=4.9.5" }, "optionalPeers": ["typescript"] }, "sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg=="], - "crc": ["crc@3.8.0", "", { "dependencies": { "buffer": "^5.1.0" } }, "sha512-iX3mfgcTMIq3ZKLIsVFAbv7+Mc10kxabAGQb8HvjA1o3T1PIYprbakQ65d3I+2HGHt6nSKkM9PYjgoJO2KcFBQ=="], - - "cross-dirname": ["cross-dirname@0.1.0", "", {}, "sha512-+R08/oI0nl3vfPcqftZRpytksBXDzOUveBq/NBVx0sUp1axwzPQrKinNx5yd5sxPu8j1wIy8AfnVQ+5eFdha6Q=="], - "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="], "crossws": ["crossws@0.3.5", "", { "dependencies": { "uncrypto": "^0.1.3" } }, "sha512-ojKiDvcmByhwa8YYqbQI/hg7MEU0NC03+pSdEq4ZUnZR9xXpwk7E43SMNGkn+JxJGPFtNvQ48+vV2p+P1ml5PA=="], @@ -1865,10 +1750,6 @@ "default-browser-id": ["default-browser-id@5.0.1", "", {}, "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q=="], - "defaults": ["defaults@1.0.4", "", { "dependencies": { "clone": "^1.0.2" } }, "sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A=="], - - "defer-to-connect": ["defer-to-connect@2.0.1", "", {}, "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg=="], - "define-data-property": ["define-data-property@1.1.4", "", { "dependencies": { "es-define-property": "^1.0.0", "es-errors": "^1.3.0", "gopd": "^1.0.1" } }, "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A=="], "define-lazy-prop": ["define-lazy-prop@3.0.0", "", {}, "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg=="], @@ -1881,8 +1762,6 @@ "delaunator": ["delaunator@5.0.1", "", { "dependencies": { "robust-predicates": "^3.0.2" } }, "sha512-8nvh+XBe96aCESrGOqMp/84b13H9cdKbG5P2ejQCh4d4sK9RL4371qou9drQjMhvnPmhWl5hnmqbEE0fXr9Xnw=="], - "delayed-stream": ["delayed-stream@1.0.0", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="], - "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="], "dequal": ["dequal@2.0.3", "", {}, "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="], @@ -1891,8 +1770,6 @@ "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="], - "detect-node": ["detect-node@2.1.0", "", {}, "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g=="], - "detect-node-es": ["detect-node-es@1.1.0", "", {}, "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ=="], "deterministic-object-hash": ["deterministic-object-hash@2.0.2", "", { "dependencies": { "base-64": "^1.0.0" } }, "sha512-KxektNH63SrbfUyDiwXqRb1rLwKt33AmMv+5Nhsw1kqZ13SJBRTgZHtGbE+hH3a1mVW1cz+4pqSWVPAtLVXTzQ=="], @@ -1903,16 +1780,10 @@ "diff": ["diff@8.0.3", "", {}, "sha512-qejHi7bcSD4hQAZE0tNAawRK1ZtafHDmMTMkrrIGgSLl7hTnQHmKCeB45xAcbfTqK2zowkM3j3bHt/4b/ARbYQ=="], - "dir-compare": ["dir-compare@4.2.0", "", { "dependencies": { "minimatch": "^3.0.5", "p-limit": "^3.1.0 " } }, "sha512-2xMCmOoMrdQIPHdsTawECdNPwlVFB9zGcz3kuhmBO6U3oU+UQjsue0i8ayLKpgBcm+hcXPMVSGUN9d+pvJ6+VQ=="], - "direction": ["direction@2.0.1", "", { "bin": { "direction": "cli.js" } }, "sha512-9S6m9Sukh1cZNknO1CWAr2QAWsbKLafQiyM5gZ7VgXHeuaoUwffKN4q6NC4A/Mf9iiPlOXQEKW/Mv/mh9/3YFA=="], "dlv": ["dlv@1.1.3", "", {}, "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA=="], - "dmg-builder": ["dmg-builder@26.8.1", "", { "dependencies": { "app-builder-lib": "26.8.1", "builder-util": "26.8.1", "fs-extra": "^10.1.0", "iconv-lite": "^0.6.2", "js-yaml": "^4.1.0" }, "optionalDependencies": { "dmg-license": "^1.0.11" } }, "sha512-glMJgnTreo8CFINujtAhCgN96QAqApDMZ8Vl1r8f0QT8QprvC1UCltV4CcWj20YoIyLZx6IUskaJZ0NV8fokcg=="], - - "dmg-license": ["dmg-license@1.0.11", "", { "dependencies": { "@types/plist": "^3.0.1", "@types/verror": "^1.10.3", "ajv": "^6.10.0", "crc": "^3.8.0", "iconv-corefoundation": "^1.1.7", "plist": "^3.0.4", "smart-buffer": "^4.0.2", "verror": "^1.10.0" }, "os": "darwin", "bin": { "dmg-license": "bin/dmg-license.js" } }, "sha512-ZdzmqwKmECOWJpqefloC5OJy1+WZBBse5+MR88z9g9Zn4VY+WYUkAyojmhzJckH5YbbZGcYIuGAkY5/Ys5OM2Q=="], - "dom-accessibility-api": ["dom-accessibility-api@0.5.16", "", {}, "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg=="], "dom-serializer": ["dom-serializer@2.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.2", "entities": "^4.2.0" } }, "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg=="], @@ -1927,8 +1798,6 @@ "dotenv": ["dotenv@17.3.1", "", {}, "sha512-IO8C/dzEb6O3F9/twg6ZLXz164a2fhTnEWb95H23Dm4OuN+92NmEAlTrupP9VW6Jm3sO26tQlqyvyi4CsnY9GA=="], - "dotenv-expand": ["dotenv-expand@11.0.7", "", { "dependencies": { "dotenv": "^16.4.5" } }, "sha512-zIHwmZPRshsCdpMDyVsqGmgyP0yT8GAgXUnkdAoJisxvf33k7yO6OuoKmcTGuXPWSsm8Oh88nZicRLA9Y0rUeA=="], - "drizzle-orm": ["drizzle-orm@0.41.0", "", { "peerDependencies": { "@aws-sdk/client-rds-data": ">=3", "@cloudflare/workers-types": ">=4", "@electric-sql/pglite": ">=0.2.0", "@libsql/client": ">=0.10.0", "@libsql/client-wasm": ">=0.10.0", "@neondatabase/serverless": ">=0.10.0", "@op-engineering/op-sqlite": ">=2", "@opentelemetry/api": "^1.4.1", "@planetscale/database": ">=1", "@prisma/client": "*", "@tidbcloud/serverless": "*", "@types/better-sqlite3": "*", "@types/pg": "*", "@types/sql.js": "*", "@vercel/postgres": ">=0.8.0", "@xata.io/client": "*", "better-sqlite3": ">=7", "bun-types": "*", "expo-sqlite": ">=14.0.0", "gel": ">=2", "knex": "*", "kysely": "*", "mysql2": ">=2", "pg": ">=8", "postgres": ">=3", "sql.js": ">=1", "sqlite3": ">=5" }, "optionalPeers": ["@aws-sdk/client-rds-data", "@cloudflare/workers-types", "@electric-sql/pglite", "@libsql/client", "@libsql/client-wasm", "@neondatabase/serverless", "@op-engineering/op-sqlite", "@opentelemetry/api", "@planetscale/database", "@prisma/client", "@tidbcloud/serverless", "@types/better-sqlite3", "@types/pg", "@types/sql.js", "@vercel/postgres", "@xata.io/client", "better-sqlite3", "bun-types", "expo-sqlite", "gel", "knex", "kysely", "mysql2", "pg", "postgres", "sql.js", "sqlite3"] }, "sha512-7A4ZxhHk9gdlXmTdPj/lREtP+3u8KvZ4yEN6MYVxBzZGex5Wtdc+CWSbu7btgF6TB0N+MNPrvW7RKBbxJchs/Q=="], "dset": ["dset@3.1.4", "", {}, "sha512-2QF/g9/zTaPDc3BjNcVTGoBbXBgYfMTTceLaYcFJ/W9kggFUkhxD/hMEeuLKbugyef9SqAx8cpgwlIP/jinUTA=="], @@ -1945,26 +1814,12 @@ "ejs": ["ejs@3.1.10", "", { "dependencies": { "jake": "^10.8.5" }, "bin": { "ejs": "bin/cli.js" } }, "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA=="], - "electron": ["electron@35.7.5", "", { "dependencies": { "@electron/get": "^2.0.0", "@types/node": "^22.7.7", "extract-zip": "^2.0.1" }, "bin": { "electron": "cli.js" } }, "sha512-dnL+JvLraKZl7iusXTVTGYs10TKfzUi30uEDTqsmTm0guN9V2tbOjTzyIZbh9n3ygUjgEYyo+igAwMRXIi3IPw=="], - - "electron-builder": ["electron-builder@26.8.1", "", { "dependencies": { "app-builder-lib": "26.8.1", "builder-util": "26.8.1", "builder-util-runtime": "9.5.1", "chalk": "^4.1.2", "ci-info": "^4.2.0", "dmg-builder": "26.8.1", "fs-extra": "^10.1.0", "lazy-val": "^1.0.5", "simple-update-notifier": "2.0.0", "yargs": "^17.6.2" }, "bin": { "electron-builder": "cli.js", "install-app-deps": "install-app-deps.js" } }, "sha512-uWhx1r74NGpCagG0ULs/P9Nqv2nsoo+7eo4fLUOB8L8MdWltq9odW/uuLXMFCDGnPafknYLZgjNX0ZIFRzOQAw=="], - - "electron-builder-squirrel-windows": ["electron-builder-squirrel-windows@26.8.1", "", { "dependencies": { "app-builder-lib": "26.8.1", "builder-util": "26.8.1", "electron-winstaller": "5.4.0" } }, "sha512-o288fIdgPLHA76eDrFADHPoo7VyGkDCYbLV1GzndaMSAVBoZrGvM9m2IehdcVMzdAZJ2eV9bgyissQXHv5tGzA=="], - - "electron-log": ["electron-log@5.4.3", "", {}, "sha512-sOUsM3LjZdugatazSQ/XTyNcw8dfvH1SYhXWiJyfYodAAKOZdHs0txPiLDXFzOZbhXgAgshQkshH2ccq0feyLQ=="], - - "electron-publish": ["electron-publish@26.8.1", "", { "dependencies": { "@types/fs-extra": "^9.0.11", "builder-util": "26.8.1", "builder-util-runtime": "9.5.1", "chalk": "^4.1.2", "form-data": "^4.0.5", "fs-extra": "^10.1.0", "lazy-val": "^1.0.5", "mime": "^2.5.2" } }, "sha512-q+jrSTIh/Cv4eGZa7oVR+grEJo/FoLMYBAnSL5GCtqwUpr1T+VgKB/dn1pnzxIxqD8S/jP1yilT9VrwCqINR4w=="], - "electron-to-chromium": ["electron-to-chromium@1.5.286", "", {}, "sha512-9tfDXhJ4RKFNerfjdCcZfufu49vg620741MNs26a9+bhLThdB+plgMeou98CAaHu/WATj2iHOOHTp1hWtABj2A=="], - "electron-winstaller": ["electron-winstaller@5.4.0", "", { "dependencies": { "@electron/asar": "^3.2.1", "debug": "^4.1.1", "fs-extra": "^7.0.1", "lodash": "^4.17.21", "temp": "^0.9.0" }, "optionalDependencies": { "@electron/windows-sign": "^1.1.2" } }, "sha512-bO3y10YikuUwUuDUQRM4KfwNkKhnpVO7IPdbsrejwN9/AABJzzTQ4GeHwyzNSrVO+tEH3/Np255a3sVZpZDjvg=="], - "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="], - "encoding": ["encoding@0.1.13", "", { "dependencies": { "iconv-lite": "^0.6.2" } }, "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A=="], - "end-of-stream": ["end-of-stream@1.4.5", "", { "dependencies": { "once": "^1.4.0" } }, "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg=="], "engine.io": ["engine.io@6.6.5", "", { "dependencies": { "@types/cors": "^2.8.12", "@types/node": ">=10.0.0", "accepts": "~1.3.4", "base64id": "2.0.0", "cookie": "~0.7.2", "cors": "~2.8.5", "debug": "~4.4.1", "engine.io-parser": "~5.2.1", "ws": "~8.18.3" } }, "sha512-2RZdgEbXmp5+dVbRm0P7HQUImZpICccJy7rN7Tv+SFa55pH+lxnuw6/K1ZxxBfHoYpSkHLAO92oa8O4SwFXA2A=="], @@ -1979,8 +1834,6 @@ "env-paths": ["env-paths@2.2.1", "", {}, "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A=="], - "err-code": ["err-code@2.0.3", "", {}, "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA=="], - "error-ex": ["error-ex@1.3.4", "", { "dependencies": { "is-arrayish": "^0.2.1" } }, "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ=="], "es-abstract": ["es-abstract@1.24.1", "", { "dependencies": { "array-buffer-byte-length": "^1.0.2", "arraybuffer.prototype.slice": "^1.0.4", "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "call-bound": "^1.0.4", "data-view-buffer": "^1.0.2", "data-view-byte-length": "^1.0.2", "data-view-byte-offset": "^1.0.1", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "es-set-tostringtag": "^2.1.0", "es-to-primitive": "^1.3.0", "function.prototype.name": "^1.1.8", "get-intrinsic": "^1.3.0", "get-proto": "^1.0.1", "get-symbol-description": "^1.1.0", "globalthis": "^1.0.4", "gopd": "^1.2.0", "has-property-descriptors": "^1.0.2", "has-proto": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "internal-slot": "^1.1.0", "is-array-buffer": "^3.0.5", "is-callable": "^1.2.7", "is-data-view": "^1.0.2", "is-negative-zero": "^2.0.3", "is-regex": "^1.2.1", "is-set": "^2.0.3", "is-shared-array-buffer": "^1.0.4", "is-string": "^1.1.1", "is-typed-array": "^1.1.15", "is-weakref": "^1.1.1", "math-intrinsics": "^1.1.0", "object-inspect": "^1.13.4", "object-keys": "^1.1.1", "object.assign": "^4.1.7", "own-keys": "^1.0.1", "regexp.prototype.flags": "^1.5.4", "safe-array-concat": "^1.1.3", "safe-push-apply": "^1.0.0", "safe-regex-test": "^1.1.0", "set-proto": "^1.0.0", "stop-iteration-iterator": "^1.1.0", "string.prototype.trim": "^1.2.10", "string.prototype.trimend": "^1.0.9", "string.prototype.trimstart": "^1.0.8", "typed-array-buffer": "^1.0.3", "typed-array-byte-length": "^1.0.3", "typed-array-byte-offset": "^1.0.4", "typed-array-length": "^1.0.7", "unbox-primitive": "^1.1.0", "which-typed-array": "^1.1.19" } }, "sha512-zHXBLhP+QehSSbsS9Pt23Gg964240DPd6QCf8WpkqEXxQ7fhdZzYsocOr5u7apWonsS5EjZDmTF+/slGMyasvw=="], @@ -1999,8 +1852,6 @@ "es-toolkit": ["es-toolkit@1.45.1", "", {}, "sha512-/jhoOj/Fx+A+IIyDNOvO3TItGmlMKhtX8ISAHKE90c4b/k1tqaqEZ+uUqfpU8DMnW5cgNJv606zS55jGvza0Xw=="], - "es6-error": ["es6-error@4.1.1", "", {}, "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg=="], - "esast-util-from-estree": ["esast-util-from-estree@2.0.0", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "devlop": "^1.0.0", "estree-util-visit": "^2.0.0", "unist-util-position-from-estree": "^2.0.0" } }, "sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ=="], "esast-util-from-js": ["esast-util-from-js@2.0.1", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "acorn": "^8.0.0", "esast-util-from-estree": "^2.0.0", "vfile-message": "^4.0.0" } }, "sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw=="], @@ -2013,7 +1864,7 @@ "escape-html": ["escape-html@1.0.3", "", {}, "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="], - "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="], + "escape-string-regexp": ["escape-string-regexp@5.0.0", "", {}, "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="], "escodegen": ["escodegen@2.1.0", "", { "dependencies": { "esprima": "^4.0.1", "estraverse": "^5.2.0", "esutils": "^2.0.2" }, "optionalDependencies": { "source-map": "~0.6.1" }, "bin": { "esgenerate": "bin/esgenerate.js", "escodegen": "bin/escodegen.js" } }, "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w=="], @@ -2049,8 +1900,6 @@ "expand-template": ["expand-template@2.0.3", "", {}, "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg=="], - "exponential-backoff": ["exponential-backoff@3.1.3", "", {}, "sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA=="], - "express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.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", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="], "express-rate-limit": ["express-rate-limit@8.2.1", "", { "dependencies": { "ip-address": "10.0.1" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g=="], @@ -2063,8 +1912,6 @@ "extract-zip": ["extract-zip@2.0.1", "", { "dependencies": { "debug": "^4.1.1", "get-stream": "^5.1.0", "yauzl": "^2.10.0" }, "optionalDependencies": { "@types/yauzl": "^2.9.1" }, "bin": { "extract-zip": "cli.js" } }, "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg=="], - "extsprintf": ["extsprintf@1.4.1", "", {}, "sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA=="], - "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="], "fast-glob": ["fast-glob@3.3.3", "", { "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" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="], @@ -2111,8 +1958,6 @@ "foreground-child": ["foreground-child@3.3.1", "", { "dependencies": { "cross-spawn": "^7.0.6", "signal-exit": "^4.0.1" } }, "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw=="], - "form-data": ["form-data@4.0.5", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w=="], - "formdata-polyfill": ["formdata-polyfill@4.0.10", "", { "dependencies": { "fetch-blob": "^3.1.2" } }, "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g=="], "forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="], @@ -2123,11 +1968,7 @@ "fs-constants": ["fs-constants@1.0.0", "", {}, "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="], - "fs-extra": ["fs-extra@10.1.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ=="], - - "fs-minipass": ["fs-minipass@3.0.3", "", { "dependencies": { "minipass": "^7.0.3" } }, "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw=="], - - "fs.realpath": ["fs.realpath@1.0.0", "", {}, "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="], + "fs-extra": ["fs-extra@11.3.3", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg=="], "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], @@ -2183,8 +2024,6 @@ "glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="], - "global-agent": ["global-agent@3.0.0", "", { "dependencies": { "boolean": "^3.0.1", "es6-error": "^4.1.1", "matcher": "^3.0.0", "roarr": "^2.15.3", "semver": "^7.3.2", "serialize-error": "^7.0.1" } }, "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q=="], - "globalthis": ["globalthis@1.0.4", "", { "dependencies": { "define-properties": "^1.2.1", "gopd": "^1.0.1" } }, "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ=="], "google-auth-library": ["google-auth-library@10.5.0", "", { "dependencies": { "base64-js": "^1.3.0", "ecdsa-sig-formatter": "^1.0.11", "gaxios": "^7.0.0", "gcp-metadata": "^8.0.0", "google-logging-utils": "^1.0.0", "gtoken": "^8.0.0", "jws": "^4.0.0" } }, "sha512-7ABviyMOlX5hIVD60YOfHw4/CxOfBhyduaYB+wbFWCWoni4N7SLcV46hrVRktuBbZjFC9ONyqamZITN7q3n32w=="], @@ -2193,8 +2032,6 @@ "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="], - "got": ["got@11.8.6", "", { "dependencies": { "@sindresorhus/is": "^4.0.0", "@szmarczak/http-timer": "^4.0.5", "@types/cacheable-request": "^6.0.1", "@types/responselike": "^1.0.0", "cacheable-lookup": "^5.0.3", "cacheable-request": "^7.0.2", "decompress-response": "^6.0.0", "http2-wrapper": "^1.0.0-beta.5.2", "lowercase-keys": "^2.0.0", "p-cancelable": "^2.0.0", "responselike": "^2.0.0" } }, "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g=="], - "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="], "graphql": ["graphql@16.12.0", "", {}, "sha512-DKKrynuQRne0PNpEbzuEdHlYOMksHSUI8Zc9Unei5gTsMNA2/vMpoMz/yKba50pejK56qj98qM0SjYxAKi13gQ=="], @@ -2291,8 +2128,6 @@ "http-proxy-agent": ["http-proxy-agent@7.0.2", "", { "dependencies": { "agent-base": "^7.1.0", "debug": "^4.3.4" } }, "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig=="], - "http2-wrapper": ["http2-wrapper@1.0.3", "", { "dependencies": { "quick-lru": "^5.1.1", "resolve-alpn": "^1.0.0" } }, "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg=="], - "http_ece": ["http_ece@1.2.0", "", {}, "sha512-JrF8SSLVmcvc5NducxgyOrKXe3EsyHMgBFgSaIUGmArKe+rwr0uphRkRXvwiom3I+fpIfoItveHrfudL8/rxuA=="], "https-proxy-agent": ["https-proxy-agent@7.0.6", "", { "dependencies": { "agent-base": "^7.1.2", "debug": "4" } }, "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw=="], @@ -2303,8 +2138,6 @@ "ico-endec": ["ico-endec@0.1.6", "", {}, "sha512-ZdLU38ZoED3g1j3iEyzcQj+wAkY2xfWNkymszfJPoxucIUhK7NayQ+/C4Kv0nDFMIsbtbEHldv3V8PU494/ueQ=="], - "iconv-corefoundation": ["iconv-corefoundation@1.1.7", "", { "dependencies": { "cli-truncate": "^2.1.0", "node-addon-api": "^1.6.3" }, "os": "darwin" }, "sha512-T10qvkw0zz4wnm560lOEg0PovVqUXuOFhhHAkixw8/sycy7TJt7v/RrkEKEQnAw2viPSJu6iAkErxnzR0g8PpQ=="], - "iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="], "idb": ["idb@7.1.1", "", {}, "sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ=="], @@ -2319,10 +2152,6 @@ "import-meta-resolve": ["import-meta-resolve@4.2.0", "", {}, "sha512-Iqv2fzaTQN28s/FwZAoFq0ZSs/7hMAHJVX+w8PZl3cY19Pxk6jFFalxQoIfW2826i/fDLXv8IiEZRIT0lDuWcg=="], - "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="], - - "inflight": ["inflight@1.0.6", "", { "dependencies": { "once": "^1.3.0", "wrappy": "1" } }, "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA=="], - "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="], "ini": ["ini@1.3.8", "", {}, "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="], @@ -2429,8 +2258,6 @@ "isarray": ["isarray@2.0.5", "", {}, "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw=="], - "isbinaryfile": ["isbinaryfile@5.0.7", "", {}, "sha512-gnWD14Jh3FzS3CPhF0AxNOJ8CxqeblPTADzI38r0wt8ZyQl5edpy75myt08EG2oKvpyiqSqsx+Wkz9vtkbTqYQ=="], - "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="], "jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="], @@ -2449,8 +2276,6 @@ "json-bigint": ["json-bigint@1.0.0", "", { "dependencies": { "bignumber.js": "^9.0.0" } }, "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ=="], - "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="], - "json-parse-even-better-errors": ["json-parse-even-better-errors@2.3.1", "", {}, "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="], "json-schema": ["json-schema@0.4.0", "", {}, "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA=="], @@ -2461,8 +2286,6 @@ "json-schema-typed": ["json-schema-typed@8.0.2", "", {}, "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA=="], - "json-stringify-safe": ["json-stringify-safe@5.0.1", "", {}, "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA=="], - "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="], "jsonfile": ["jsonfile@6.2.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg=="], @@ -2475,8 +2298,6 @@ "katex": ["katex@0.16.28", "", { "dependencies": { "commander": "^8.3.0" }, "bin": { "katex": "cli.js" } }, "sha512-YHzO7721WbmAL6Ov1uzN/l5mY5WWWhJBSW+jq4tkfZfsxmo1hu6frS0EOswvjBUnWE6NtjEs48SFn5CQESRLZg=="], - "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="], - "khroma": ["khroma@2.1.0", "", {}, "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw=="], "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="], @@ -2493,8 +2314,6 @@ "layout-base": ["layout-base@1.0.2", "", {}, "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg=="], - "lazy-val": ["lazy-val@1.0.5", "", {}, "sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q=="], - "lefthook": ["lefthook@2.1.1", "", { "optionalDependencies": { "lefthook-darwin-arm64": "2.1.1", "lefthook-darwin-x64": "2.1.1", "lefthook-freebsd-arm64": "2.1.1", "lefthook-freebsd-x64": "2.1.1", "lefthook-linux-arm64": "2.1.1", "lefthook-linux-x64": "2.1.1", "lefthook-openbsd-arm64": "2.1.1", "lefthook-openbsd-x64": "2.1.1", "lefthook-windows-arm64": "2.1.1", "lefthook-windows-x64": "2.1.1" }, "bin": { "lefthook": "bin/index.js" } }, "sha512-Tl9h9c+sG3ShzTHKuR3LAIblnnh+Mgxnm2Ul7yu9cu260Z27LEbO3V6Zw4YZFP59/2rlD42pt/llYsQCkkCFzw=="], "lefthook-darwin-arm64": ["lefthook-darwin-arm64@2.1.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-O/RS1j03/Fnq5zCzEb2r7UOBsqPeBuf1C5pMkIJcO4TSE6hf3rhLUkcorKc2M5ni/n5zLGtzQUXHV08/fSAT3Q=="], @@ -2569,8 +2388,6 @@ "loose-envify": ["loose-envify@1.4.0", "", { "dependencies": { "js-tokens": "^3.0.0 || ^4.0.0" }, "bin": { "loose-envify": "cli.js" } }, "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q=="], - "lowercase-keys": ["lowercase-keys@2.0.0", "", {}, "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA=="], - "lru-cache": ["lru-cache@7.18.3", "", {}, "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA=="], "lucide-react": ["lucide-react@0.575.0", "", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-VuXgKZrk0uiDlWjGGXmKV6MSk9Yy4l10qgVvzGn2AWBx1Ylt0iBexKOAoA6I7JO3m+M9oeovJd3yYENfkUbOeg=="], @@ -2583,16 +2400,12 @@ "make-dir": ["make-dir@3.1.0", "", { "dependencies": { "semver": "^6.0.0" } }, "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw=="], - "make-fetch-happen": ["make-fetch-happen@14.0.3", "", { "dependencies": { "@npmcli/agent": "^3.0.0", "cacache": "^19.0.1", "http-cache-semantics": "^4.1.1", "minipass": "^7.0.2", "minipass-fetch": "^4.0.0", "minipass-flush": "^1.0.5", "minipass-pipeline": "^1.2.4", "negotiator": "^1.0.0", "proc-log": "^5.0.0", "promise-retry": "^2.0.1", "ssri": "^12.0.0" } }, "sha512-QMjGbFTP0blj97EeidG5hk/QhKQ3T4ICckQGLgz38QF7Vgbk6e6FTARN8KhKxyBbWn8R0HU+bnw8aSoFPD4qtQ=="], - "markdown-extensions": ["markdown-extensions@2.0.0", "", {}, "sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q=="], "markdown-table": ["markdown-table@3.0.4", "", {}, "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw=="], "marked": ["marked@15.0.12", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-8dD6FusOQSrpv9Z1rdNMdlSgQOIP880DHqnohobOmYLElGEqAL/JvxvuxZO16r4HtjTlfPRDC1hbvxC9dPN2nA=="], - "matcher": ["matcher@3.0.0", "", { "dependencies": { "escape-string-regexp": "^4.0.0" } }, "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng=="], - "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="], "mdast-util-definitions": ["mdast-util-definitions@6.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-scTllyX6pnYNZH/AIp/0ePz6s4cZtARxImwoPJ7kS42n+MnVsI4XbnG6d4ibehRIldYMWM2LD7ImQblVhUejVQ=="], @@ -2727,8 +2540,6 @@ "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="], - "mime": ["mime@2.6.0", "", { "bin": { "mime": "cli.js" } }, "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg=="], - "mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="], "mime-types": ["mime-types@3.0.2", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A=="], @@ -2747,20 +2558,8 @@ "minipass": ["minipass@7.1.3", "", {}, "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A=="], - "minipass-collect": ["minipass-collect@2.0.1", "", { "dependencies": { "minipass": "^7.0.3" } }, "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw=="], - - "minipass-fetch": ["minipass-fetch@4.0.1", "", { "dependencies": { "minipass": "^7.0.3", "minipass-sized": "^1.0.3", "minizlib": "^3.0.1" }, "optionalDependencies": { "encoding": "^0.1.13" } }, "sha512-j7U11C5HXigVuutxebFadoYBbd7VSdZWggSe64NVdvWNBqGAiXPL2QVCehjmw7lY1oF9gOllYbORh+hiNgfPgQ=="], - - "minipass-flush": ["minipass-flush@1.0.7", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-TbqTz9cUwWyHS2Dy89P3ocAGUGxKjjLuR9z8w4WUTGAVgEj17/4nhgo2Du56i0Fm3Pm30g4iA8Lcqctc76jCzA=="], - - "minipass-pipeline": ["minipass-pipeline@1.2.4", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A=="], - - "minipass-sized": ["minipass-sized@1.0.3", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g=="], - "minizlib": ["minizlib@3.1.0", "", { "dependencies": { "minipass": "^7.1.2" } }, "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw=="], - "mkdirp": ["mkdirp@0.5.6", "", { "dependencies": { "minimist": "^1.2.6" }, "bin": { "mkdirp": "bin/cmd.js" } }, "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw=="], - "mkdirp-classic": ["mkdirp-classic@0.5.3", "", {}, "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A=="], "mlly": ["mlly@1.8.0", "", { "dependencies": { "acorn": "^8.15.0", "pathe": "^2.0.3", "pkg-types": "^1.3.1", "ufo": "^1.6.1" } }, "sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g=="], @@ -2797,11 +2596,7 @@ "nlcst-to-string": ["nlcst-to-string@4.0.0", "", { "dependencies": { "@types/nlcst": "^2.0.0" } }, "sha512-YKLBCcUYKAg0FNlOBT6aI91qFmSiFKiluk655WzPF+DDMA02qIyy8uiRqI8QXtcFpEvll12LpL5MXqEmAZ+dcA=="], - "node-abi": ["node-abi@4.28.0", "", { "dependencies": { "semver": "^7.6.3" } }, "sha512-Qfp5XZL1cJDOabOT8H5gnqMTmM4NjvYzHp4I/Kt/Sl76OVkOBBHRFlPspGV0hYvMoqQsypFjT/Yp7Km0beXW9g=="], - - "node-addon-api": ["node-addon-api@1.7.2", "", {}, "sha512-ibPK3iA+vaY1eEjESkQkM0BbCqFOaZMiXRTtdB0u7b4djtY6JnsjvPdUHVMg6xQt3B8fpTTWHI9A+ADjM9frzg=="], - - "node-api-version": ["node-api-version@0.2.1", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-2xP/IGGMmmSQpI1+O/k72jF/ykvZ89JeuKX3TLJAYPDVLUalrshrLHkeVcCCZqG/eEa635cr8IBYzgnDvM2O8Q=="], + "node-abi": ["node-abi@3.87.0", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-+CGM1L1CgmtheLcBuleyYOn7NWPVu0s0EJH2C4puxgEZb9h8QpR9G2dBfZJOAUhi7VQxuBPMd0hiISWcTyiYyQ=="], "node-domexception": ["node-domexception@1.0.0", "", {}, "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ=="], @@ -2809,18 +2604,12 @@ "node-fetch-native": ["node-fetch-native@1.6.7", "", {}, "sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q=="], - "node-gyp": ["node-gyp@11.5.0", "", { "dependencies": { "env-paths": "^2.2.0", "exponential-backoff": "^3.1.1", "graceful-fs": "^4.2.6", "make-fetch-happen": "^14.0.3", "nopt": "^8.0.0", "proc-log": "^5.0.0", "semver": "^7.3.5", "tar": "^7.4.3", "tinyglobby": "^0.2.12", "which": "^5.0.0" }, "bin": { "node-gyp": "bin/node-gyp.js" } }, "sha512-ra7Kvlhxn5V9Slyus0ygMa2h+UqExPqUIkfk7Pc8QTLT956JLSy51uWFwHtIYy0vI8cB4BDhc/S03+880My/LQ=="], - "node-mock-http": ["node-mock-http@1.0.4", "", {}, "sha512-8DY+kFsDkNXy1sJglUfuODx1/opAGJGyrTuFqEoN90oRc2Vk0ZbD4K2qmKXBBEhZQzdKHIVfEJpDU8Ak2NJEvQ=="], "node-releases": ["node-releases@2.0.27", "", {}, "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA=="], - "nopt": ["nopt@8.1.0", "", { "dependencies": { "abbrev": "^3.0.0" }, "bin": { "nopt": "bin/nopt.js" } }, "sha512-ieGu42u/Qsa4TFktmaKEwM6MQH0pOWnaB3htzh0JRtx84+Mebc0cbZYN5bC+6WTZ4+77xrL9Pn5m7CV6VIkV7A=="], - "normalize-path": ["normalize-path@3.0.0", "", {}, "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA=="], - "normalize-url": ["normalize-url@6.1.0", "", {}, "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A=="], - "notepack.io": ["notepack.io@3.0.1", "", {}, "sha512-TKC/8zH5pXIAMVQio2TvVDTtPRX+DJPHDqjRbxogtFiByHyzKmy96RA0JtCQJ+WouyyL4A10xomQzgbUT+1jCg=="], "npm-run-path": ["npm-run-path@6.0.0", "", { "dependencies": { "path-key": "^4.0.0", "unicorn-magic": "^0.3.0" } }, "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA=="], @@ -2863,14 +2652,10 @@ "own-keys": ["own-keys@1.0.1", "", { "dependencies": { "get-intrinsic": "^1.2.6", "object-keys": "^1.1.1", "safe-push-apply": "^1.0.0" } }, "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg=="], - "p-cancelable": ["p-cancelable@2.1.1", "", {}, "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg=="], - "p-limit": ["p-limit@6.2.0", "", { "dependencies": { "yocto-queue": "^1.1.1" } }, "sha512-kuUqqHNUqoIWp/c467RI4X6mmyuojY5jGutNU0wVTmEOOfcuwLqyMVoAi9MKi2Ak+5i9+nhmrK4ufZE8069kHA=="], "p-locate": ["p-locate@4.1.0", "", { "dependencies": { "p-limit": "^2.2.0" } }, "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A=="], - "p-map": ["p-map@7.0.4", "", {}, "sha512-tkAQEw8ysMzmkhgw8k+1U/iPhWNhykKnSk4Rd5zLoPJCuJaGRPo6YposrZgaxHKzDHdDWWZvE/Sk7hsL2X/CpQ=="], - "p-queue": ["p-queue@8.1.1", "", { "dependencies": { "eventemitter3": "^5.0.1", "p-timeout": "^6.1.2" } }, "sha512-aNZ+VfjobsWryoiPnEApGGmf5WmNsCo9xu8dfaYamG5qaLP7ClhLN6NgsFe6SwJ2UbLEBK5dv9x8Mn5+RVhMWQ=="], "p-retry": ["p-retry@4.6.2", "", { "dependencies": { "@types/retry": "0.12.0", "retry": "^0.13.1" } }, "sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ=="], @@ -2913,8 +2698,6 @@ "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="], - "path-is-absolute": ["path-is-absolute@1.0.1", "", {}, "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg=="], - "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="], "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="], @@ -2925,8 +2708,6 @@ "pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="], - "pe-library": ["pe-library@0.4.1", "", {}, "sha512-eRWB5LBz7PpDu4PUlwT0PhnQfTQJlDDdPa35urV4Osrm0t0AqQFGn+UIkU3klZvwJ8KPO3VbBFsXquA6p6kqZw=="], - "pend": ["pend@1.2.0", "", {}, "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg=="], "perfect-debounce": ["perfect-debounce@2.1.0", "", {}, "sha512-LjgdTytVFXeUgtHZr9WYViYSM/g8MkcTPYDlPa3cDqMirHjKiSZPYd6DoL7pK8AJQr+uWkQvCjHNdiMqsrJs+g=="], @@ -2965,8 +2746,6 @@ "playwright-core": ["playwright-core@1.58.2", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-yZkEtftgwS8CsfYo7nm0KE8jsvm6i/PTgVtB8DL726wNf6H2IMsDuxCpJj59KDaxCtSnrWan2AeDqM7JBaultg=="], - "plist": ["plist@3.1.0", "", { "dependencies": { "@xmldom/xmldom": "^0.8.8", "base64-js": "^1.5.1", "xmlbuilder": "^15.1.1" } }, "sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ=="], - "points-on-curve": ["points-on-curve@0.2.0", "", {}, "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A=="], "points-on-path": ["points-on-path@0.2.1", "", { "dependencies": { "path-data-parser": "0.1.0", "points-on-curve": "0.2.0" } }, "sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g=="], @@ -2987,8 +2766,6 @@ "postgres-interval": ["postgres-interval@1.2.0", "", { "dependencies": { "xtend": "^4.0.0" } }, "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ=="], - "postject": ["postject@1.0.0-alpha.6", "", { "dependencies": { "commander": "^9.4.0" }, "bin": { "postject": "dist/cli.js" } }, "sha512-b9Eb8h2eVqNE8edvKdwqkrY6O7kAwmI8kcnBv1NScolYJbo59XUF0noFq+lxbC1yN20bmC0WBEbDC5H/7ASb0A=="], - "powershell-utils": ["powershell-utils@0.1.0", "", {}, "sha512-dM0jVuXJPsDN6DvRpea484tCUaMiXWjuCn++HGTqUWzGDjv5tZkEZldAJ/UMlqRYGFrD/etByo4/xOuC/snX2A=="], "prebuild-install": ["prebuild-install@7.1.3", "", { "dependencies": { "detect-libc": "^2.0.0", "expand-template": "^2.0.3", "github-from-package": "0.0.0", "minimist": "^1.2.3", "mkdirp-classic": "^0.5.3", "napi-build-utils": "^2.0.0", "node-abi": "^3.3.0", "pump": "^3.0.0", "rc": "^1.2.7", "simple-get": "^4.0.0", "tar-fs": "^2.0.0", "tunnel-agent": "^0.6.0" }, "bin": { "prebuild-install": "bin.js" } }, "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug=="], @@ -3003,12 +2780,6 @@ "prismjs": ["prismjs@1.30.0", "", {}, "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw=="], - "proc-log": ["proc-log@5.0.0", "", {}, "sha512-Azwzvl90HaF0aCz1JrDdXQykFakSSNPaPoiZ9fm5qJIMHioDZEi7OAdRwSm6rSoPtY3Qutnm3L7ogmg3dc+wbQ=="], - - "progress": ["progress@2.0.3", "", {}, "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA=="], - - "promise-retry": ["promise-retry@2.0.1", "", { "dependencies": { "err-code": "^2.0.2", "retry": "^0.12.0" } }, "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g=="], - "prompts": ["prompts@2.4.2", "", { "dependencies": { "kleur": "^3.0.3", "sisteransi": "^1.0.5" } }, "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q=="], "prop-types": ["prop-types@15.8.1", "", { "dependencies": { "loose-envify": "^1.4.0", "object-assign": "^4.1.1", "react-is": "^16.13.1" } }, "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg=="], @@ -3035,8 +2806,6 @@ "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="], - "quick-lru": ["quick-lru@5.1.1", "", {}, "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA=="], - "radix-ui": ["radix-ui@1.4.3", "", { "dependencies": { "@radix-ui/primitive": "1.1.3", "@radix-ui/react-accessible-icon": "1.1.7", "@radix-ui/react-accordion": "1.2.12", "@radix-ui/react-alert-dialog": "1.1.15", "@radix-ui/react-arrow": "1.1.7", "@radix-ui/react-aspect-ratio": "1.1.7", "@radix-ui/react-avatar": "1.1.10", "@radix-ui/react-checkbox": "1.3.3", "@radix-ui/react-collapsible": "1.1.12", "@radix-ui/react-collection": "1.1.7", "@radix-ui/react-compose-refs": "1.1.2", "@radix-ui/react-context": "1.1.2", "@radix-ui/react-context-menu": "2.2.16", "@radix-ui/react-dialog": "1.1.15", "@radix-ui/react-direction": "1.1.1", "@radix-ui/react-dismissable-layer": "1.1.11", "@radix-ui/react-dropdown-menu": "2.1.16", "@radix-ui/react-focus-guards": "1.1.3", "@radix-ui/react-focus-scope": "1.1.7", "@radix-ui/react-form": "0.1.8", "@radix-ui/react-hover-card": "1.1.15", "@radix-ui/react-label": "2.1.7", "@radix-ui/react-menu": "2.1.16", "@radix-ui/react-menubar": "1.1.16", "@radix-ui/react-navigation-menu": "1.2.14", "@radix-ui/react-one-time-password-field": "0.1.8", "@radix-ui/react-password-toggle-field": "0.1.3", "@radix-ui/react-popover": "1.1.15", "@radix-ui/react-popper": "1.2.8", "@radix-ui/react-portal": "1.1.9", "@radix-ui/react-presence": "1.1.5", "@radix-ui/react-primitive": "2.1.3", "@radix-ui/react-progress": "1.1.7", "@radix-ui/react-radio-group": "1.3.8", "@radix-ui/react-roving-focus": "1.1.11", "@radix-ui/react-scroll-area": "1.2.10", "@radix-ui/react-select": "2.2.6", "@radix-ui/react-separator": "1.1.7", "@radix-ui/react-slider": "1.3.6", "@radix-ui/react-slot": "1.2.3", "@radix-ui/react-switch": "1.2.6", "@radix-ui/react-tabs": "1.1.13", "@radix-ui/react-toast": "1.2.15", "@radix-ui/react-toggle": "1.1.10", "@radix-ui/react-toggle-group": "1.1.11", "@radix-ui/react-toolbar": "1.1.11", "@radix-ui/react-tooltip": "1.2.8", "@radix-ui/react-use-callback-ref": "1.1.1", "@radix-ui/react-use-controllable-state": "1.2.2", "@radix-ui/react-use-effect-event": "0.0.2", "@radix-ui/react-use-escape-keydown": "1.1.1", "@radix-ui/react-use-is-hydrated": "0.1.0", "@radix-ui/react-use-layout-effect": "1.1.1", "@radix-ui/react-use-size": "1.1.1", "@radix-ui/react-visually-hidden": "1.2.3" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-aWizCQiyeAenIdUbqEpXgRA1ya65P13NKn/W8rWkcN0OPkRDxdBVLWnIEDsS2RpwCK2nobI7oMUSmexzTDyAmA=="], "radix3": ["radix3@1.1.2", "", {}, "sha512-b484I/7b8rDEdSDKckSSBA8knMpcdsXudlE/LNL639wFoHKwLbEkQFZHWEYwDC0wa0FKUcCY+GAF73Z7wxNVFA=="], @@ -3071,8 +2840,6 @@ "react-style-singleton": ["react-style-singleton@2.2.3", "", { "dependencies": { "get-nonce": "^1.0.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ=="], - "read-binary-file-arch": ["read-binary-file-arch@1.0.6", "", { "dependencies": { "debug": "^4.3.4" }, "bin": { "read-binary-file-arch": "cli.js" } }, "sha512-BNg9EN3DD3GsDXX7Aa8O4p92sryjkmzYYgmgTAc6CA4uGLEDzFfxOxugu21akOxpcXHiEgsYkC6nPsQvLLLmEg=="], - "readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="], "readdirp": ["readdirp@5.0.0", "", {}, "sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ=="], @@ -3165,18 +2932,12 @@ "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="], - "resedit": ["resedit@1.7.2", "", { "dependencies": { "pe-library": "^0.4.1" } }, "sha512-vHjcY2MlAITJhC0eRD/Vv8Vlgmu9Sd3LX9zZvtGzU5ZImdTN3+d6e/4mnTyV8vEbyf1sgNIrWxhWlrys52OkEA=="], - "reselect": ["reselect@5.1.1", "", {}, "sha512-K/BG6eIky/SBpzfHZv/dd+9JBFiS4SWV7FIujVyJRux6e45+73RaUHXLmIR1f7WOMaQ0U1km6qwklRQxpJJY0w=="], "resolve": ["resolve@1.22.11", "", { "dependencies": { "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ=="], - "resolve-alpn": ["resolve-alpn@1.2.1", "", {}, "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g=="], - "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="], - "responselike": ["responselike@2.0.1", "", { "dependencies": { "lowercase-keys": "^2.0.0" } }, "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw=="], - "restore-cursor": ["restore-cursor@5.1.0", "", { "dependencies": { "onetime": "^7.0.0", "signal-exit": "^4.1.0" } }, "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA=="], "retext": ["retext@9.0.0", "", { "dependencies": { "@types/nlcst": "^2.0.0", "retext-latin": "^4.0.0", "retext-stringify": "^4.0.0", "unified": "^11.0.0" } }, "sha512-sbMDcpHCNjvlheSgMfEcVrZko3cDzdbe1x/e7G66dFp0Ff7Mldvi2uv6JkJQzdRcvLYE8CA8Oe8siQx8ZOgTcA=="], @@ -3195,8 +2956,6 @@ "rimraf": ["rimraf@5.0.10", "", { "dependencies": { "glob": "^10.3.7" }, "bin": { "rimraf": "dist/esm/bin.mjs" } }, "sha512-l0OE8wL34P4nJH/H2ffoaniAokM2qSmrtXHmlpvYr5AVVX8msAyW0l8NVJFDxlSK4u3Uh/f41cQheDVdnYijwQ=="], - "roarr": ["roarr@2.15.4", "", { "dependencies": { "boolean": "^3.0.1", "detect-node": "^2.0.4", "globalthis": "^1.0.1", "json-stringify-safe": "^5.0.1", "semver-compare": "^1.0.0", "sprintf-js": "^1.1.2" } }, "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A=="], - "robust-predicates": ["robust-predicates@3.0.2", "", {}, "sha512-IXgzBWvWQwE6PrDI05OvmXUIruQTcoMDzRsOd5CDvHCVLcLHMTSYvOK5Cm46kWqlV3yAbuSpBZdJ5oP5OUoStg=="], "rollup": ["rollup@4.57.1", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.57.1", "@rollup/rollup-android-arm64": "4.57.1", "@rollup/rollup-darwin-arm64": "4.57.1", "@rollup/rollup-darwin-x64": "4.57.1", "@rollup/rollup-freebsd-arm64": "4.57.1", "@rollup/rollup-freebsd-x64": "4.57.1", "@rollup/rollup-linux-arm-gnueabihf": "4.57.1", "@rollup/rollup-linux-arm-musleabihf": "4.57.1", "@rollup/rollup-linux-arm64-gnu": "4.57.1", "@rollup/rollup-linux-arm64-musl": "4.57.1", "@rollup/rollup-linux-loong64-gnu": "4.57.1", "@rollup/rollup-linux-loong64-musl": "4.57.1", "@rollup/rollup-linux-ppc64-gnu": "4.57.1", "@rollup/rollup-linux-ppc64-musl": "4.57.1", "@rollup/rollup-linux-riscv64-gnu": "4.57.1", "@rollup/rollup-linux-riscv64-musl": "4.57.1", "@rollup/rollup-linux-s390x-gnu": "4.57.1", "@rollup/rollup-linux-x64-gnu": "4.57.1", "@rollup/rollup-linux-x64-musl": "4.57.1", "@rollup/rollup-openbsd-x64": "4.57.1", "@rollup/rollup-openharmony-arm64": "4.57.1", "@rollup/rollup-win32-arm64-msvc": "4.57.1", "@rollup/rollup-win32-ia32-msvc": "4.57.1", "@rollup/rollup-win32-x64-gnu": "4.57.1", "@rollup/rollup-win32-x64-msvc": "4.57.1", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A=="], @@ -3225,20 +2984,14 @@ "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="], - "sanitize-filename": ["sanitize-filename@1.6.4", "", { "dependencies": { "truncate-utf8-bytes": "^1.0.0" } }, "sha512-9ZyI08PsvdQl2r/bBIGubpVdR3RR9sY6RDiWFPreA21C/EFlQhmgo20UZlNjZMMZNubusLhAQozkA0Od5J21Eg=="], - "sax": ["sax@1.4.4", "", {}, "sha512-1n3r/tGXO6b6VXMdFT54SHzT9ytu9yr7TaELowdYpMqY/Ao7EnlQGmAQ1+RatX7Tkkdm6hONI2owqNx2aZj5Sw=="], "scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="], "semver": ["semver@7.7.4", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="], - "semver-compare": ["semver-compare@1.0.0", "", {}, "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow=="], - "send": ["send@1.2.1", "", { "dependencies": { "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.1", "mime-types": "^3.0.2", "ms": "^2.1.3", "on-finished": "^2.4.1", "range-parser": "^1.2.1", "statuses": "^2.0.2" } }, "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ=="], - "serialize-error": ["serialize-error@7.0.1", "", { "dependencies": { "type-fest": "^0.13.1" } }, "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw=="], - "serialize-javascript": ["serialize-javascript@6.0.2", "", { "dependencies": { "randombytes": "^2.1.0" } }, "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g=="], "serve-static": ["serve-static@2.2.1", "", { "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "parseurl": "^1.3.3", "send": "^1.2.0" } }, "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw=="], @@ -3283,14 +3036,10 @@ "simple-swizzle": ["simple-swizzle@0.2.4", "", { "dependencies": { "is-arrayish": "^0.3.1" } }, "sha512-nAu1WFPQSMNr2Zn9PGSZK9AGn4t/y97lEm+MXTtUDwfP0ksAIX4nO+6ruD9Jwut4C49SB1Ws+fbXsm/yScWOHw=="], - "simple-update-notifier": ["simple-update-notifier@2.0.0", "", { "dependencies": { "semver": "^7.5.3" } }, "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w=="], - "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="], "sitemap": ["sitemap@8.0.2", "", { "dependencies": { "@types/node": "^17.0.5", "@types/sax": "^1.2.1", "arg": "^5.0.0", "sax": "^1.4.1" }, "bin": { "sitemap": "dist/cli.js" } }, "sha512-LwktpJcyZDoa0IL6KT++lQ53pbSrx2c9ge41/SeLTyqy2XUNA6uR4+P9u5IVo5lPeL2arAcOKn1aZAxoYbCKlQ=="], - "slice-ansi": ["slice-ansi@3.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "astral-regex": "^2.0.0", "is-fullwidth-code-point": "^3.0.0" } }, "sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ=="], - "smart-buffer": ["smart-buffer@4.2.0", "", {}, "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg=="], "smob": ["smob@1.6.1", "", {}, "sha512-KAkBqZl3c2GvNgNhcoyJae1aKldDW0LO279wF9bk1PnluRTETKBq0WyzRXxEhoQLk56yHaOY4JCBEKDuJIET5g=="], @@ -3321,12 +3070,6 @@ "split2": ["split2@4.2.0", "", {}, "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg=="], - "sprintf-js": ["sprintf-js@1.1.3", "", {}, "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA=="], - - "ssri": ["ssri@12.0.0", "", { "dependencies": { "minipass": "^7.0.3" } }, "sha512-S7iGNosepx9RadX82oimUkvr0Ct7IjJbEbs4mJcTxst8um95J3sDYU1RBEOvdu6oL1Wek2ODI5i4MAw+dZ6cAQ=="], - - "stat-mode": ["stat-mode@1.0.0", "", {}, "sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg=="], - "statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="], "std-env": ["std-env@3.10.0", "", {}, "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg=="], @@ -3381,8 +3124,6 @@ "stylis": ["stylis@4.3.6", "", {}, "sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ=="], - "sumchecker": ["sumchecker@3.0.1", "", { "dependencies": { "debug": "^4.1.0" } }, "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg=="], - "supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="], "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="], @@ -3403,12 +3144,8 @@ "tar-stream": ["tar-stream@2.2.0", "", { "dependencies": { "bl": "^4.0.3", "end-of-stream": "^1.4.1", "fs-constants": "^1.0.0", "inherits": "^2.0.3", "readable-stream": "^3.1.1" } }, "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ=="], - "temp": ["temp@0.9.4", "", { "dependencies": { "mkdirp": "^0.5.1", "rimraf": "~2.6.2" } }, "sha512-yYrrsWnrXMcdsnu/7YMYAofM1ktpL5By7vZhf15CrXijWWrEYZks5AXBudalfSWJLlnen/QUJUB5aoB0kqZUGA=="], - "temp-dir": ["temp-dir@2.0.0", "", {}, "sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg=="], - "temp-file": ["temp-file@3.4.0", "", { "dependencies": { "async-exit-hook": "^2.0.1", "fs-extra": "^10.0.0" } }, "sha512-C5tjlC/HCtVUOi3KWVokd4vHVViOmGjtLwIh4MuzPo/nMYTV/p1urt3RnMz2IWXDdKEGJH3k5+KPxtqRsUYGtg=="], - "tempy": ["tempy@0.6.0", "", { "dependencies": { "is-stream": "^2.0.0", "temp-dir": "^2.0.0", "type-fest": "^0.16.0", "unique-string": "^2.0.0" } }, "sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw=="], "terser": ["terser@5.46.0", "", { "dependencies": { "@jridgewell/source-map": "^0.3.3", "acorn": "^8.15.0", "commander": "^2.20.0", "source-map-support": "~0.5.20" }, "bin": { "terser": "bin/terser" } }, "sha512-jTwoImyr/QbOWFFso3YoU3ik0jBBDJ6JTOQiy/J2YxVJdZCc+5u7skhNwiOR3FQIygFqVUPHl7qbbxtjW2K3Qg=="], @@ -3417,8 +3154,6 @@ "thenify-all": ["thenify-all@1.6.0", "", { "dependencies": { "thenify": ">= 3.1.0 < 4" } }, "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA=="], - "tiny-async-pool": ["tiny-async-pool@1.3.0", "", { "dependencies": { "semver": "^5.5.0" } }, "sha512-01EAw5EDrcVrdgyCLgoSPvqznC0sVxDSVeiOz09FUpjh71G79VCqneOr+xvt7T1r76CF6ZZfPjHorN2+d+3mqA=="], - "tiny-inflate": ["tiny-inflate@1.0.3", "", {}, "sha512-pkY1fj1cKHb2seWDy0B16HeWyczlJA9/WW3u3c4z/NiWDsO3DOU5D7nhTLE9CF0yXv/QZFY7sEJmj24dK+Rrqw=="], "tiny-invariant": ["tiny-invariant@1.3.3", "", {}, "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg=="], @@ -3433,8 +3168,6 @@ "tmp": ["tmp@0.2.5", "", {}, "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow=="], - "tmp-promise": ["tmp-promise@3.0.3", "", { "dependencies": { "tmp": "^0.2.0" } }, "sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ=="], - "to-data-view": ["to-data-view@1.1.0", "", {}, "sha512-1eAdufMg6mwgmlojAx3QeMnzB/BTVp7Tbndi3U7ftcT2zCZadjxkkmLmd97zmaxWi+sgGcgWrokmpEoy0Dn0vQ=="], "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="], @@ -3453,8 +3186,6 @@ "trough": ["trough@2.2.0", "", {}, "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw=="], - "truncate-utf8-bytes": ["truncate-utf8-bytes@1.0.2", "", { "dependencies": { "utf8-byte-length": "^1.0.1" } }, "sha512-95Pu1QXQvruGEhv62XCMO3Mm90GscOCClvrIUwCM0PYOXK3kaF3l3sIHxx71ThJfcbM2O5Au6SO3AWCSEfW4mQ=="], - "ts-algebra": ["ts-algebra@2.0.0", "", {}, "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw=="], "ts-dedent": ["ts-dedent@2.2.0", "", {}, "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ=="], @@ -3523,10 +3254,6 @@ "unifont": ["unifont@0.7.4", "", { "dependencies": { "css-tree": "^3.1.0", "ofetch": "^1.5.1", "ohash": "^2.0.11" } }, "sha512-oHeis4/xl42HUIeHuNZRGEvxj5AaIKR+bHPNegRq5LV1gdc3jundpONbjglKpihmJf+dswygdMJn3eftGIMemg=="], - "unique-filename": ["unique-filename@4.0.0", "", { "dependencies": { "unique-slug": "^5.0.0" } }, "sha512-XSnEewXmQ+veP7xX2dS5Q4yZAvO40cBN2MWkJ7D/6sW4Dg6wYBNwM1Vrnz1FhH5AdeLIlUXRI9e28z1YZi71NQ=="], - - "unique-slug": ["unique-slug@5.0.0", "", { "dependencies": { "imurmurhash": "^0.1.4" } }, "sha512-9OdaqO5kwqR+1kVgHAhsp5vPNU0hnxRa26rBFNfNgM7M6pNtgzeBn3s/xbyCQL3dcjzOatcef6UUHpB/6MaETg=="], - "unique-string": ["unique-string@2.0.0", "", { "dependencies": { "crypto-random-string": "^2.0.0" } }, "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg=="], "unist-util-find-after": ["unist-util-find-after@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ=="], @@ -3561,8 +3288,6 @@ "update-browserslist-db": ["update-browserslist-db@1.2.3", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w=="], - "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="], - "use-callback-ref": ["use-callback-ref@1.3.3", "", { "dependencies": { "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg=="], "use-sidecar": ["use-sidecar@1.1.3", "", { "dependencies": { "detect-node-es": "^1.1.0", "tslib": "^2.0.0" }, "peerDependencies": { "@types/react": "*", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ=="], @@ -3571,8 +3296,6 @@ "use-sync-external-store": ["use-sync-external-store@1.6.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w=="], - "utf8-byte-length": ["utf8-byte-length@1.0.5", "", {}, "sha512-Xn0w3MtiQ6zoz2vFyUVruaCL53O/DwUvkEeOvj+uulMm0BkUGYWmBYVyElqZaSLhY6ZD0ulfU3aBra2aVT4xfA=="], - "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="], "uuid": ["uuid@8.3.2", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="], @@ -3581,8 +3304,6 @@ "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="], - "verror": ["verror@1.10.1", "", { "dependencies": { "assert-plus": "^1.0.0", "core-util-is": "1.0.2", "extsprintf": "^1.2.0" } }, "sha512-veufcmxri4e3XSrT0xwfUR7kguIkaxBeosDg00yDWhk49wdwkSUrvvsm7nc75e1PUyvIeZj6nS8VQRYz2/S4Xg=="], - "vfile": ["vfile@6.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile-message": "^4.0.0" } }, "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q=="], "vfile-location": ["vfile-location@5.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile": "^6.0.0" } }, "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg=="], @@ -3609,8 +3330,6 @@ "vscode-uri": ["vscode-uri@3.1.0", "", {}, "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ=="], - "wcwidth": ["wcwidth@1.0.1", "", { "dependencies": { "defaults": "^1.0.3" } }, "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg=="], - "web-namespaces": ["web-namespaces@2.0.1", "", {}, "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ=="], "web-push": ["web-push@3.6.7", "", { "dependencies": { "asn1.js": "^5.3.0", "http_ece": "1.2.0", "https-proxy-agent": "^7.0.0", "jws": "^4.0.0", "minimist": "^1.2.5" }, "bin": { "web-push": "src/cli.js" } }, "sha512-OpiIUe8cuGjrj3mMBFWY+e4MMIkW3SVT+7vEIjvD9kejGUypv8GPDf84JdPWskK8zMRIJ6xYGm+Kxr8YkPyA0A=="], @@ -3681,8 +3400,6 @@ "wsl-utils": ["wsl-utils@0.1.0", "", { "dependencies": { "is-wsl": "^3.1.0" } }, "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw=="], - "xmlbuilder": ["xmlbuilder@15.1.1", "", {}, "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg=="], - "xmlhttprequest-ssl": ["xmlhttprequest-ssl@2.1.2", "", {}, "sha512-TEU+nJVUUnA4CYJFLvK5X9AOeH4KvDvhIfm0vV1GaQRtchnG0hgK5p8hw/xjv8cunWYCsiPCSDzObPyhEwq3KQ=="], "xtend": ["xtend@4.0.2", "", {}, "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="], @@ -3757,8 +3474,6 @@ "@better-auth/cli/chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="], - "@develar/schema-utils/ajv": ["ajv@6.14.0", "", { "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" } }, "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw=="], - "@dotenvx/dotenvx/commander": ["commander@11.1.0", "", {}, "sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ=="], "@dotenvx/dotenvx/execa": ["execa@5.1.1", "", { "dependencies": { "cross-spawn": "^7.0.3", "get-stream": "^6.0.0", "human-signals": "^2.1.0", "is-stream": "^2.0.0", "merge-stream": "^2.0.0", "npm-run-path": "^4.0.1", "onetime": "^5.1.2", "signal-exit": "^3.0.3", "strip-final-newline": "^2.0.0" } }, "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg=="], @@ -3769,30 +3484,6 @@ "@ecies/ciphers/@noble/ciphers": ["@noble/ciphers@1.3.0", "", {}, "sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw=="], - "@electron/asar/commander": ["commander@5.1.0", "", {}, "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg=="], - - "@electron/asar/glob": ["glob@7.2.3", "", { "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" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="], - - "@electron/asar/minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="], - - "@electron/fuses/fs-extra": ["fs-extra@9.1.0", "", { "dependencies": { "at-least-node": "^1.0.0", "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ=="], - - "@electron/get/fs-extra": ["fs-extra@8.1.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^4.0.0", "universalify": "^0.1.0" } }, "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g=="], - - "@electron/get/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], - - "@electron/notarize/fs-extra": ["fs-extra@9.1.0", "", { "dependencies": { "at-least-node": "^1.0.0", "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ=="], - - "@electron/osx-sign/isbinaryfile": ["isbinaryfile@4.0.10", "", {}, "sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw=="], - - "@electron/rebuild/ora": ["ora@5.4.1", "", { "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" } }, "sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ=="], - - "@electron/universal/fs-extra": ["fs-extra@11.3.3", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg=="], - - "@electron/universal/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], - - "@electron/windows-sign/fs-extra": ["fs-extra@11.3.3", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg=="], - "@inquirer/core/signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="], "@inquirer/core/wrap-ansi": ["wrap-ansi@6.2.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA=="], @@ -3801,8 +3492,6 @@ "@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="], - "@malept/flatpak-bundler/fs-extra": ["fs-extra@9.1.0", "", { "dependencies": { "at-least-node": "^1.0.0", "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ=="], - "@mariozechner/pi-ai/chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="], "@mariozechner/pi-coding-agent/chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="], @@ -3813,8 +3502,6 @@ "@noble/curves/@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="], - "@npmcli/agent/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="], - "@pizzapi/ui/motion": ["motion@12.34.3", "", { "dependencies": { "framer-motion": "^12.34.3", "tslib": "^2.4.0" }, "peerDependencies": { "@emotion/is-prop-valid": "*", "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" }, "optionalPeers": ["@emotion/is-prop-valid", "react", "react-dom"] }, "sha512-xZIkBGO7v/Uvm+EyaqYd+9IpXu0sZqLywVlGdCFrrMiaO9JI4Kx51mO9KlHSWwll+gZUVY5OJsWgYI5FywJ/tw=="], "@radix-ui/react-alert-dialog/@radix-ui/react-slot": ["@radix-ui/react-slot@1.2.3", "", { "dependencies": { "@radix-ui/react-compose-refs": "1.1.2" }, "peerDependencies": { "@types/react": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react"] }, "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A=="], @@ -3879,20 +3566,8 @@ "accepts/mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="], - "ajv-keywords/ajv": ["ajv@6.14.0", "", { "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" } }, "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw=="], - "anymatch/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="], - "app-builder-lib/@electron/get": ["@electron/get@3.1.0", "", { "dependencies": { "debug": "^4.1.1", "env-paths": "^2.2.0", "fs-extra": "^8.1.0", "got": "^11.8.5", "progress": "^2.0.3", "semver": "^6.2.0", "sumchecker": "^3.0.1" }, "optionalDependencies": { "global-agent": "^3.0.0" } }, "sha512-F+nKc0xW+kVbBRhFzaMgPy3KwmuNTYX1fx6+FxxoSnNgwYX6LD7AKBTWkU0MQ6IBoe7dz069CNkR673sPAgkCQ=="], - - "app-builder-lib/ci-info": ["ci-info@4.3.1", "", {}, "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA=="], - - "app-builder-lib/dotenv": ["dotenv@16.6.1", "", {}, "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow=="], - - "app-builder-lib/hosted-git-info": ["hosted-git-info@4.1.0", "", { "dependencies": { "lru-cache": "^6.0.0" } }, "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA=="], - - "app-builder-lib/which": ["which@5.0.0", "", { "dependencies": { "isexe": "^3.1.1" }, "bin": { "node-which": "bin/which.js" } }, "sha512-JEdGzHwwkrbWoGOlIHqQ5gtprKGOenpDHpxE9zVR1bWbOtYRyPPHMe9FaP6x61CmNaTThSkb0DAJte5jD+DmzQ=="], - "astro/sharp": ["sharp@0.34.5", "", { "dependencies": { "@img/colour": "^1.0.0", "detect-libc": "^2.1.2", "semver": "^7.7.3" }, "optionalDependencies": { "@img/sharp-darwin-arm64": "0.34.5", "@img/sharp-darwin-x64": "0.34.5", "@img/sharp-libvips-darwin-arm64": "1.2.4", "@img/sharp-libvips-darwin-x64": "1.2.4", "@img/sharp-libvips-linux-arm": "1.2.4", "@img/sharp-libvips-linux-arm64": "1.2.4", "@img/sharp-libvips-linux-ppc64": "1.2.4", "@img/sharp-libvips-linux-riscv64": "1.2.4", "@img/sharp-libvips-linux-s390x": "1.2.4", "@img/sharp-libvips-linux-x64": "1.2.4", "@img/sharp-libvips-linuxmusl-arm64": "1.2.4", "@img/sharp-libvips-linuxmusl-x64": "1.2.4", "@img/sharp-linux-arm": "0.34.5", "@img/sharp-linux-arm64": "0.34.5", "@img/sharp-linux-ppc64": "0.34.5", "@img/sharp-linux-riscv64": "0.34.5", "@img/sharp-linux-s390x": "0.34.5", "@img/sharp-linux-x64": "0.34.5", "@img/sharp-linuxmusl-arm64": "0.34.5", "@img/sharp-linuxmusl-x64": "0.34.5", "@img/sharp-wasm32": "0.34.5", "@img/sharp-win32-arm64": "0.34.5", "@img/sharp-win32-ia32": "0.34.5", "@img/sharp-win32-x64": "0.34.5" } }, "sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg=="], "astro/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="], @@ -3905,10 +3580,6 @@ "boxen/string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="], - "cacache/glob": ["glob@10.5.0", "", { "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" } }, "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg=="], - - "cacache/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="], - "chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="], "chevrotain-allstar/chevrotain": ["chevrotain@11.1.1", "", { "dependencies": { "@chevrotain/cst-dts-gen": "11.1.1", "@chevrotain/gast": "11.1.1", "@chevrotain/regexp-to-ast": "11.1.1", "@chevrotain/types": "11.1.1", "@chevrotain/utils": "11.1.1", "lodash-es": "4.17.23" } }, "sha512-f0yv5CPKaFxfsPTBzX7vGuim4oIC1/gcS7LUGdBSwl2dU6+FON6LVUksdOo1qJjoUvXNn45urgh8C+0a24pACQ=="], @@ -3919,8 +3590,6 @@ "cliui/wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="], - "clone-response/mimic-response": ["mimic-response@1.0.1", "", {}, "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ=="], - "cmdk/@radix-ui/react-primitive": ["@radix-ui/react-primitive@2.1.4", "", { "dependencies": { "@radix-ui/react-slot": "1.2.4" }, "peerDependencies": { "@types/react": "*", "@types/react-dom": "*", "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc" }, "optionalPeers": ["@types/react", "@types/react-dom"] }, "sha512-9hQc4+GNVtJAIEPEqlYqW5RiYdrr8ea5XQ0ZOnD6fgru+83kqT15mq2OCcbe8KnjRZl5vF3ks69AKz3kh1jrhg=="], "csso/css-tree": ["css-tree@2.2.1", "", { "dependencies": { "mdn-data": "2.0.28", "source-map-js": "^1.0.1" } }, "sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA=="], @@ -3937,26 +3606,12 @@ "degenerator/ast-types": ["ast-types@0.13.4", "", { "dependencies": { "tslib": "^2.0.1" } }, "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w=="], - "dir-compare/minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="], - - "dir-compare/p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="], - - "dmg-builder/iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="], - - "dmg-license/ajv": ["ajv@6.14.0", "", { "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" } }, "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw=="], - "dom-serializer/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="], - "dotenv-expand/dotenv": ["dotenv@16.6.1", "", {}, "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow=="], - "eciesjs/@noble/ciphers": ["@noble/ciphers@1.3.0", "", {}, "sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw=="], "eciesjs/@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="], - "electron-winstaller/fs-extra": ["fs-extra@7.0.1", "", { "dependencies": { "graceful-fs": "^4.1.2", "jsonfile": "^4.0.0", "universalify": "^0.1.0" } }, "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw=="], - - "encoding/iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="], - "engine.io/cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="], "engine.io/ws": ["ws@8.18.3", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg=="], @@ -3979,8 +3634,6 @@ "foreground-child/signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="], - "form-data/mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="], - "get-uri/data-uri-to-buffer": ["data-uri-to-buffer@6.0.2", "", {}, "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw=="], "glob/minimatch": ["minimatch@10.2.2", "", { "dependencies": { "brace-expansion": "^5.0.2" } }, "sha512-+G4CpNBxa5MprY+04MbgOw1v7So6n5JY166pFi9KfYwT78fxScCeSNQSNzp6dpPSW2rONOps6Ocam1wFhCgoVw=="], @@ -4001,28 +3654,16 @@ "make-dir/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], - "make-fetch-happen/negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="], - - "mdast-util-find-and-replace/escape-string-regexp": ["escape-string-regexp@5.0.0", "", {}, "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="], - "mermaid/marked": ["marked@16.4.2", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA=="], "mermaid/uuid": ["uuid@11.1.0", "", { "bin": { "uuid": "dist/esm/bin/uuid" } }, "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A=="], "micromatch/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="], - "minipass-flush/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="], - - "minipass-pipeline/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="], - - "minipass-sized/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="], - "mlly/pkg-types": ["pkg-types@1.3.1", "", { "dependencies": { "confbox": "^0.1.8", "mlly": "^1.7.4", "pathe": "^2.0.1" } }, "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ=="], "msw/type-fest": ["type-fest@5.4.4", "", { "dependencies": { "tagged-tag": "^1.0.0" } }, "sha512-JnTrzGu+zPV3aXIUhnyWJj4z/wigMsdYajGLIYakqyOW1nPllzXEJee0QQbHj+CTIQtXGlAjuK0UY+2xTyjVAw=="], - "node-gyp/which": ["which@5.0.0", "", { "dependencies": { "isexe": "^3.1.1" }, "bin": { "node-which": "bin/which.js" } }, "sha512-JEdGzHwwkrbWoGOlIHqQ5gtprKGOenpDHpxE9zVR1bWbOtYRyPPHMe9FaP6x61CmNaTThSkb0DAJte5jD+DmzQ=="], - "npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="], "nypm/citty": ["citty@0.2.1", "", {}, "sha512-kEV95lFBhQgtogAPlQfJJ0WGVSokvLr/UEoFPiKKOXF7pl98HfUVUD0ejsuTCld/9xH9vogSywZ5KqHzXrZpqg=="], @@ -4047,10 +3688,6 @@ "postcss-nested/postcss-selector-parser": ["postcss-selector-parser@6.1.2", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg=="], - "postject/commander": ["commander@9.5.0", "", {}, "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ=="], - - "prebuild-install/node-abi": ["node-abi@3.87.0", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-+CGM1L1CgmtheLcBuleyYOn7NWPVu0s0EJH2C4puxgEZb9h8QpR9G2dBfZJOAUhi7VQxuBPMd0hiISWcTyiYyQ=="], - "pretty-format/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], "pretty-format/ansi-styles": ["ansi-styles@5.2.0", "", {}, "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA=="], @@ -4073,18 +3710,16 @@ "router/path-to-regexp": ["path-to-regexp@8.3.0", "", {}, "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA=="], - "serialize-error/type-fest": ["type-fest@0.13.1", "", {}, "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg=="], - "shadcn/@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.26.0", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-Y5RmPncpiDtTXDbLKswIJzTqu2hyBKxTNsgKqKclDbhIgg1wgtf1fRuvxgTnRfcnxtvvgbIEcqUOzZrJ6iSReg=="], "shadcn/commander": ["commander@14.0.3", "", {}, "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw=="], - "shadcn/fs-extra": ["fs-extra@11.3.3", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-VWSRii4t0AFm6ixFFmLLx1t7wS1gh+ckoa84aOeapGum0h+EZd1EhEumSB+ZdDLnEPuucsVB9oB7cxJHap6Afg=="], - "shadcn/open": ["open@11.0.0", "", { "dependencies": { "default-browser": "^5.4.0", "define-lazy-prop": "^3.0.0", "is-in-ssh": "^1.0.0", "is-inside-container": "^1.0.0", "powershell-utils": "^0.1.0", "wsl-utils": "^0.3.0" } }, "sha512-smsWv2LzFjP03xmvFoJ331ss6h+jixfA4UUV/Bsiyuu4YJPfN+FIQGOIiv4w9/+MoHkfkJ22UIaQWRVFRfH6Vw=="], "shadcn/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="], + "sitemap/@types/node": ["@types/node@17.0.45", "", {}, "sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw=="], + "socket.io-adapter/ws": ["ws@8.18.3", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg=="], "socks/ip-address": ["ip-address@10.1.0", "", {}, "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q=="], @@ -4101,16 +3736,12 @@ "tar-fs/chownr": ["chownr@1.1.4", "", {}, "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg=="], - "temp/rimraf": ["rimraf@2.6.3", "", { "dependencies": { "glob": "^7.1.3" }, "bin": { "rimraf": "./bin.js" } }, "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA=="], - "tempy/is-stream": ["is-stream@2.0.1", "", {}, "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="], "tempy/type-fest": ["type-fest@0.16.0", "", {}, "sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg=="], "terser/commander": ["commander@2.20.3", "", {}, "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="], - "tiny-async-pool/semver": ["semver@5.7.2", "", { "bin": { "semver": "bin/semver" } }, "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g=="], - "unstorage/lru-cache": ["lru-cache@11.2.6", "", {}, "sha512-ESL2CrkS/2wTPfuend7Zhkzo2u0daGJ/A2VucJOgQ/C48S/zB8MMeMHSGKYpXhIjbPxfuezITkaBH1wqv00DDQ=="], "vite/esbuild": ["esbuild@0.25.12", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.12", "@esbuild/android-arm": "0.25.12", "@esbuild/android-arm64": "0.25.12", "@esbuild/android-x64": "0.25.12", "@esbuild/darwin-arm64": "0.25.12", "@esbuild/darwin-x64": "0.25.12", "@esbuild/freebsd-arm64": "0.25.12", "@esbuild/freebsd-x64": "0.25.12", "@esbuild/linux-arm": "0.25.12", "@esbuild/linux-arm64": "0.25.12", "@esbuild/linux-ia32": "0.25.12", "@esbuild/linux-loong64": "0.25.12", "@esbuild/linux-mips64el": "0.25.12", "@esbuild/linux-ppc64": "0.25.12", "@esbuild/linux-riscv64": "0.25.12", "@esbuild/linux-s390x": "0.25.12", "@esbuild/linux-x64": "0.25.12", "@esbuild/netbsd-arm64": "0.25.12", "@esbuild/netbsd-x64": "0.25.12", "@esbuild/openbsd-arm64": "0.25.12", "@esbuild/openbsd-x64": "0.25.12", "@esbuild/openharmony-arm64": "0.25.12", "@esbuild/sunos-x64": "0.25.12", "@esbuild/win32-arm64": "0.25.12", "@esbuild/win32-ia32": "0.25.12", "@esbuild/win32-x64": "0.25.12" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg=="], @@ -4145,8 +3776,6 @@ "@babel/helper-compilation-targets/lru-cache/yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="], - "@develar/schema-utils/ajv/json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], - "@dotenvx/dotenvx/execa/get-stream": ["get-stream@6.0.1", "", {}, "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg=="], "@dotenvx/dotenvx/execa/human-signals": ["human-signals@2.1.0", "", {}, "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw=="], @@ -4159,24 +3788,6 @@ "@dotenvx/dotenvx/which/isexe": ["isexe@3.1.5", "", {}, "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w=="], - "@electron/asar/minimatch/brace-expansion": ["brace-expansion@1.1.13", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w=="], - - "@electron/get/fs-extra/jsonfile": ["jsonfile@4.0.0", "", { "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg=="], - - "@electron/get/fs-extra/universalify": ["universalify@0.1.2", "", {}, "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg=="], - - "@electron/rebuild/ora/cli-cursor": ["cli-cursor@3.1.0", "", { "dependencies": { "restore-cursor": "^3.1.0" } }, "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw=="], - - "@electron/rebuild/ora/is-interactive": ["is-interactive@1.0.0", "", {}, "sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w=="], - - "@electron/rebuild/ora/is-unicode-supported": ["is-unicode-supported@0.1.0", "", {}, "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw=="], - - "@electron/rebuild/ora/log-symbols": ["log-symbols@4.1.0", "", { "dependencies": { "chalk": "^4.1.0", "is-unicode-supported": "^0.1.0" } }, "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg=="], - - "@electron/rebuild/ora/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], - - "@electron/universal/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], - "@inquirer/core/wrap-ansi/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], "@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="], @@ -4199,16 +3810,6 @@ "accepts/mime-types/mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="], - "ajv-keywords/ajv/json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], - - "app-builder-lib/@electron/get/fs-extra": ["fs-extra@8.1.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^4.0.0", "universalify": "^0.1.0" } }, "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g=="], - - "app-builder-lib/@electron/get/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], - - "app-builder-lib/hosted-git-info/lru-cache": ["lru-cache@6.0.0", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA=="], - - "app-builder-lib/which/isexe": ["isexe@3.1.5", "", {}, "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w=="], - "astro/sharp/@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.2.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w=="], "astro/sharp/@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.2.4" }, "os": "darwin", "cpu": "x64" }, "sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw=="], @@ -4249,10 +3850,6 @@ "boxen/string-width/emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="], - "cacache/glob/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], - - "cacache/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="], - "chevrotain-allstar/chevrotain/@chevrotain/cst-dts-gen": ["@chevrotain/cst-dts-gen@11.1.1", "", { "dependencies": { "@chevrotain/gast": "11.1.1", "@chevrotain/types": "11.1.1", "lodash-es": "4.17.23" } }, "sha512-fRHyv6/f542qQqiRGalrfJl/evD39mAvbJLCekPazhiextEatq1Jx1K/i9gSd5NNO0ds03ek0Cbo/4uVKmOBcw=="], "chevrotain-allstar/chevrotain/@chevrotain/gast": ["@chevrotain/gast@11.1.1", "", { "dependencies": { "@chevrotain/types": "11.1.1", "lodash-es": "4.17.23" } }, "sha512-Ko/5vPEYy1vn5CbCjjvnSO4U7GgxyGm+dfUZZJIWTlQFkXkyym0jFYrWEU10hyCjrA7rQtiHtBr0EaZqvHFZvg=="], @@ -4273,22 +3870,10 @@ "d3-sankey/d3-shape/d3-path": ["d3-path@1.0.9", "", {}, "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg=="], - "dir-compare/minimatch/brace-expansion": ["brace-expansion@1.1.13", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w=="], - - "dir-compare/p-limit/yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="], - - "dmg-license/ajv/json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], - - "electron-winstaller/fs-extra/jsonfile": ["jsonfile@4.0.0", "", { "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg=="], - - "electron-winstaller/fs-extra/universalify": ["universalify@0.1.2", "", {}, "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg=="], - "express/accepts/negotiator": ["negotiator@1.0.0", "", {}, "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg=="], "filelist/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], - "form-data/mime-types/mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="], - "hast-util-from-html/parse5/entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="], "hast-util-raw/parse5/entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="], @@ -4301,16 +3886,8 @@ "langium/chevrotain/@chevrotain/utils": ["@chevrotain/utils@11.1.1", "", {}, "sha512-71eTYMzYXYSFPrbg/ZwftSaSDld7UYlS8OQa3lNnn9jzNtpFbaReRRyghzqS7rI3CDaorqpPJJcXGHK+FE1TVQ=="], - "minipass-flush/minipass/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="], - - "minipass-pipeline/minipass/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="], - - "minipass-sized/minipass/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="], - "mlly/pkg-types/confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="], - "node-gyp/which/isexe": ["isexe@3.1.5", "", {}, "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w=="], - "ora/string-width/emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="], "rimraf/glob/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], @@ -4325,8 +3902,6 @@ "string-width/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], - "temp/rimraf/glob": ["glob@7.2.3", "", { "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" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="], - "vite/esbuild/@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.12", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA=="], "vite/esbuild/@esbuild/android-arm": ["@esbuild/android-arm@0.25.12", "", { "os": "android", "cpu": "arm" }, "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg=="], @@ -4399,50 +3974,24 @@ "@aws-crypto/util/@smithy/util-utf8/@smithy/util-buffer-from/@smithy/is-array-buffer": ["@smithy/is-array-buffer@2.2.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA=="], - "@electron/asar/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], - - "@electron/rebuild/ora/cli-cursor/restore-cursor": ["restore-cursor@3.1.0", "", { "dependencies": { "onetime": "^5.1.0", "signal-exit": "^3.0.2" } }, "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA=="], - - "@electron/rebuild/ora/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], - - "@electron/universal/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], - "@inquirer/core/wrap-ansi/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], "@pizzapi/ui/motion/framer-motion/motion-dom": ["motion-dom@12.34.3", "", { "dependencies": { "motion-utils": "^12.29.2" } }, "sha512-sYgFe+pR9aIM7o4fhs2aXtOI+oqlUd33N9Yoxcgo1Fv7M20sRkHtCmzE/VRNIcq7uNJ+qio+Xubt1FXH3pQ+eQ=="], - "app-builder-lib/@electron/get/fs-extra/jsonfile": ["jsonfile@4.0.0", "", { "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg=="], - - "app-builder-lib/@electron/get/fs-extra/universalify": ["universalify@0.1.2", "", {}, "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg=="], - - "app-builder-lib/hosted-git-info/lru-cache/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="], - - "cacache/glob/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], - "cli-highlight/yargs/cliui/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], "cli-highlight/yargs/cliui/wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="], - "dir-compare/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], - "filelist/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], "rimraf/glob/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], "rimraf/glob/path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="], - "temp/rimraf/glob/minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="], - "workbox-build/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@9.0.0", "", {}, "sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg=="], - "cacache/glob/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], - "cli-highlight/yargs/cliui/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], "rimraf/glob/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], - - "temp/rimraf/glob/minimatch/brace-expansion": ["brace-expansion@1.1.13", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w=="], - - "temp/rimraf/glob/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], } } diff --git a/package.json b/package.json index 8fcc0d829..8682bf257 100644 --- a/package.json +++ b/package.json @@ -8,8 +8,7 @@ "packages/server", "packages/ui", "packages/cli", - "packages/docs", - "packages/desktop" + "packages/docs" ], "scripts": { "build": "bun run build:protocol && bun run build:tunnel && bun run build:tools && bun run build:server && bun run build:ui && bun run build:cli", @@ -58,7 +57,5 @@ "@mariozechner/pi-coding-agent@0.63.1": "patches/@mariozechner%2Fpi-coding-agent@0.63.1.patch", "@mariozechner/pi-ai@0.63.1": "patches/@mariozechner%2Fpi-ai@0.63.1.patch" }, - "overrides": { - "@types/node": "22.19.15" - } + } \ No newline at end of file diff --git a/packages/desktop/package.json b/packages/desktop/package.json index dd2e1340a..bb386a2fc 100644 --- a/packages/desktop/package.json +++ b/packages/desktop/package.json @@ -14,7 +14,6 @@ "start": "electron ." }, "dependencies": { - "@pizzapi/protocol": "workspace:*", "electron-log": "^5.3.0" }, "devDependencies": { diff --git a/packages/desktop/tsconfig.json b/packages/desktop/tsconfig.json index 14f0dcd39..84703dec7 100644 --- a/packages/desktop/tsconfig.json +++ b/packages/desktop/tsconfig.json @@ -9,8 +9,5 @@ "declaration": true, "sourceMap": true }, - "include": ["src"], - "references": [ - { "path": "../protocol" } - ] + "include": ["src"] }